@gajae-code/coding-agent 0.2.1 → 0.2.2

package/src/commands/ralplan.ts

@@ -1,31 +1,19 @@
 import { Command } from "@gajae-code/utils/cli";
-import { syncSkillActiveState } from "../skill-state/active-state";
-import { runGjcRuntimeBridgeWithHudSidecar } from "./gjc-runtime-bridge";
+import { runNativeRalplanCommand } from "../gjc-runtime/ralplan-runtime";
 
 export default class Ralplan extends Command {
-	static description = "Run private GJC RALPLAN workflow commands";
+	static description = "Run native GJC RALPLAN consensus planning workflow";
 	static strict = false;
-	static examples = ["$ gjc ralplan --help"];
+	static examples = [
+		'$ gjc ralplan "<task description>"',
+		'$ gjc ralplan --interactive --deliberate "<task description>"',
+		'$ gjc ralplan --write --stage planner --stage_n 1 --artifact "<markdown or path>"',
+	];
 
 	async run(): Promise<void> {
-		const cwd = process.cwd();
-		const result = await runGjcRuntimeBridgeWithHudSidecar("ralplan", this.argv, {
-			cwd,
-			sidecarSkill: "ralplan",
-			onHudPayload: payload =>
-				syncSkillActiveState({
-					cwd,
-					skill: "ralplan",
-					active: payload.active ?? true,
-					phase: payload.phase,
-					sessionId: payload.session_id,
-					threadId: payload.thread_id,
-					turnId: payload.turn_id,
-					hud: payload.hud,
-					source: "gjc-runtime-bridge",
-				}),
-		});
-		if (result.error) process.stderr.write(`${result.error}\n`);
+		const result = await runNativeRalplanCommand(this.argv, process.cwd());
+		if (result.stdout) process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
 		process.exitCode = result.status;
 	}
 }

package/src/commands/session.ts

@@ -0,0 +1,150 @@
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import {
+	attachGjcTmuxSession,
+	createGjcTmuxSession,
+	listGjcTmuxSessions,
+	removeGjcTmuxSession,
+	statusGjcTmuxSession,
+} from "../gjc-runtime/tmux-sessions";
+
+function writeJson(value: unknown): void {
+	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+function writeText(lines: string[]): void {
+	process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+function writeJsonFailure(error: unknown): void {
+	const message = error instanceof Error ? error.message : String(error);
+	const [reason = "session_error"] = message.split(":");
+	writeJson({ ok: false, reason });
+}
+
+interface SessionJsonDto {
+	name: string;
+	attached: boolean;
+	windows: number;
+	panes: number;
+	bindings: string;
+	createdAt: string;
+}
+
+function sessionJson(session: SessionJsonDto): SessionJsonDto {
+	return {
+		name: session.name,
+		attached: session.attached,
+		windows: session.windows,
+		panes: session.panes,
+		bindings: session.bindings,
+		createdAt: session.createdAt,
+	};
+}
+
+export default class Session extends Command {
+	static description = "List, inspect, attach, and remove tagged GJC-managed tmux sessions";
+	static strict = false;
+
+	static args = {
+		action: Args.string({
+			description: "list (default), status, create, attach, or remove",
+			required: false,
+		}),
+		session: Args.string({
+			description: "Session name for status, attach, or remove",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
+	};
+
+	static examples = [
+		"gjc session list",
+		"gjc session create",
+		"gjc session status <session>",
+		"gjc session attach <session>",
+		"gjc session remove <session>",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Session);
+		const action = args.action ?? "list";
+		const sessionName = args.session;
+		const json = flags.json ?? false;
+		try {
+			if (action === "list") {
+				const sessions = listGjcTmuxSessions();
+				if (json) {
+					writeJson({ ok: true, sessions: sessions.map(sessionJson) });
+					return;
+				}
+				writeText(
+					sessions.map(session =>
+						[
+							session.name,
+							`windows=${session.windows}`,
+							`attached=${session.attached}`,
+							`createdAt=${session.createdAt}`,
+							`panes=${session.panes}`,
+							`bindings=${session.bindings || "none"}`,
+						].join("\t"),
+					),
+				);
+				return;
+			}
+
+			if (action === "create") {
+				const session = createGjcTmuxSession();
+				if (json) {
+					writeJson({ ok: true, session: sessionJson(session) });
+					return;
+				}
+				writeText([`created: ${session.name}`]);
+				return;
+			}
+
+			if (!sessionName) throw new Error("missing_session_name");
+
+			if (action === "status") {
+				const session = statusGjcTmuxSession(sessionName);
+				if (json) {
+					writeJson({ ok: true, session: sessionJson(session) });
+					return;
+				}
+				writeText([
+					`session: ${session.name}`,
+					`windows: ${session.windows}`,
+					`attached: ${session.attached}`,
+					`createdAt: ${session.createdAt}`,
+					`panes: ${session.panes}`,
+					`bindings: ${session.bindings || "none"}`,
+				]);
+				return;
+			}
+
+			if (action === "remove" || action === "rm" || action === "delete") {
+				const removed = removeGjcTmuxSession(sessionName);
+				if (json) {
+					writeJson({ ok: true, session: sessionJson(removed) });
+					return;
+				}
+				writeText([`removed: ${removed.name}`]);
+				return;
+			}
+
+			if (action === "attach") {
+				attachGjcTmuxSession(sessionName);
+				return;
+			}
+			throw new Error(`unknown_session_action:${action}`);
+		} catch (error) {
+			if (json) {
+				writeJsonFailure(error);
+				return;
+			}
+			throw error;
+		}
+	}
+}

package/src/commands/state.ts

@@ -1,12 +1,22 @@
 import { Command } from "@gajae-code/utils/cli";
-import { runBridgedRuntimeEndpoint } from "./gjc-runtime-bridge";
+import { runNativeStateCommand } from "../gjc-runtime/state-runtime";
 
 export default class State extends Command {
-	static description = "Read or update private GJC workflow state";
+	static description = "Read or update GJC workflow state receipts under .gjc/state";
 	static strict = false;
-	static examples = ['$ gjc state read --input \'{"mode":"team"}\' --json'];
+	static examples = [
+		'$ gjc state read --input \'{"mode":"deep-interview"}\' --json',
+		'$ gjc state write --input \'{"state":{"interview_id":"abc"}}\' --mode deep-interview --json',
+		"$ gjc state clear --mode deep-interview",
+		"$ gjc state deep-interview read --json",
+		'$ gjc state ralplan write --input \'{"phase":"approval","active":true}\' --json',
+		"$ gjc state team contract",
+	];
 
 	async run(): Promise<void> {
-		await runBridgedRuntimeEndpoint("state", this.argv);
+		const result = await runNativeStateCommand(this.argv);
+		if (result.stdout) process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
+		process.exitCode = result.status;
 	}
 }

package/src/commands/team.ts

@@ -42,6 +42,18 @@ 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[] {
@@ -64,7 +76,7 @@ function parseInputFlag(argv: string[]): Record<string, unknown> {
 }
 
 export default class Team extends Command {
-	static description = "Run native GJC tmux team orchestration commands";
+	static description = "Run native GJC tmux team orchestration; --dry-run writes ephemeral .gjc/state/team state only";
 	static strict = false;
 
 	static args = {
@@ -76,13 +88,18 @@ export default class Team extends Command {
 
 	static flags = {
 		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
-		"dry-run": Flags.boolean({ description: "Create team state without starting tmux panes", default: false }),
+		"dry-run": Flags.boolean({
+			description:
+				"Create ephemeral .gjc/state/team state without starting tmux panes; do not commit generated state",
+			default: false,
+		}),
 	};
 
 	static examples = [
 		'gjc team 3:executor "Implement the approved plan"',
 		"gjc team status <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>",
 	];
 
@@ -118,6 +135,8 @@ export default class Team extends Command {
 				`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),
 			]);
 			return;
@@ -141,7 +160,7 @@ export default class Team extends Command {
 			if (!operation || operation === "--help" || operation === "help") {
 				writeText([
 					"Supported operations:",
-					"send-message broadcast mailbox-list mailbox-mark-delivered mailbox-mark-notified",
+					"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",
@@ -176,6 +195,7 @@ export default class Team extends Command {
 			`tmux: ${snapshot.tmux_session}`,
 			`state: ${snapshot.state_dir}`,
 			`workers: ${snapshot.workers.length}`,
+			...(dryRun ? ["dry-run: wrote ephemeral .gjc/state/team state only; do not commit generated .gjc state"] : []),
 		]);
 	}
 }

package/src/config/model-registry.ts

@@ -243,6 +243,10 @@ interface ProviderValidationConfig {
 	models: ProviderValidationModel[];
 }
 
+function usesAwsCredentialChain(api: Api | undefined): boolean {
+	return api === "bedrock-converse-stream";
+}
+
 function validateProviderConfiguration(
 	providerName: string,
 	config: ProviderValidationConfig,
@@ -274,10 +278,14 @@ function validateProviderConfiguration(
 		if (!config.baseUrl) {
 			throw new Error(`Provider ${providerName}: "baseUrl" is required when defining custom models.`);
 		}
+		const usesProviderCredentialChain = usesAwsCredentialChain(config.api);
 		const requiresAuth =
 			mode === "runtime-register"
-				? !config.apiKey && !config.oauthConfigured
-				: !config.apiKey && !config.apiKeyEnv && (config.auth ?? "apiKey") !== "none";
+				? !usesProviderCredentialChain && !config.apiKey && !config.oauthConfigured
+				: !usesProviderCredentialChain &&
+					!config.apiKey &&
+					!config.apiKeyEnv &&
+					(config.auth ?? "apiKey") !== "none";
 		if (requiresAuth) {
 			throw new Error(
 				mode === "runtime-register"

package/src/config/models-config-schema.ts

@@ -63,76 +63,86 @@ const ModelThinkingSchema = z.object({
 	levels: z.array(EffortSchema).optional(),
 });
 
-const RequestTransformSchema = z.object({
-	profile: z.enum(["openai-proxy"]).optional(),
-	stripHeaders: z.array(z.string().min(1)).optional(),
-	setHeaders: z.record(z.string(), z.string().nullable()).optional(),
-	extraBody: z.record(z.string(), z.unknown()).optional(),
-});
+const RequestTransformSchema = z
+	.object({
+		profile: z.enum(["openai-proxy"]).optional(),
+		stripHeaders: z.array(z.string().min(1)).optional(),
+		setHeaders: z.record(z.string(), z.string().nullable()).optional(),
+		extraBody: z.record(z.string(), z.unknown()).optional(),
+	})
+	.strict();
 
 const ModelBindingsSchema = z.object({
 	modelRoles: z.record(z.string(), z.string().min(1)).optional(),
 	agentModelOverrides: z.record(z.string(), z.string().min(1)).optional(),
 });
 
-const ModelDefinitionSchema = z.object({
-	id: z.string().min(1),
-	name: z.string().min(1).optional(),
-	api: z
-		.enum([
-			"openai-completions",
-			"openai-responses",
-			"openai-codex-responses",
-			"azure-openai-responses",
-			"anthropic-messages",
-			"google-generative-ai",
-			"google-vertex",
-		])
-		.optional(),
-	baseUrl: z.string().min(1).optional(),
-	reasoning: z.boolean().optional(),
-	thinking: ModelThinkingSchema.optional(),
-	input: z.array(z.enum(["text", "image"])).optional(),
-	cost: z
-		.object({
-			input: z.number(),
-			output: z.number(),
-			cacheRead: z.number(),
-			cacheWrite: z.number(),
-		})
-		.optional(),
-	premiumMultiplier: z.number().optional(),
-	contextWindow: z.number().optional(),
-	maxTokens: z.number().optional(),
-	headers: z.record(z.string(), z.string()).optional(),
-	compat: OpenAICompatSchema.optional(),
-	contextPromotionTarget: z.string().min(1).optional(),
-	wireModelId: z.string().min(1).optional(),
-	requestTransform: RequestTransformSchema.optional(),
-});
-
-export const ModelOverrideSchema = z.object({
-	name: z.string().min(1).optional(),
-	reasoning: z.boolean().optional(),
-	thinking: ModelThinkingSchema.optional(),
-	input: z.array(z.enum(["text", "image"])).optional(),
-	cost: z
-		.object({
-			input: z.number().optional(),
-			output: z.number().optional(),
-			cacheRead: z.number().optional(),
-			cacheWrite: z.number().optional(),
-		})
-		.optional(),
-	premiumMultiplier: z.number().optional(),
-	contextWindow: z.number().optional(),
-	maxTokens: z.number().optional(),
-	headers: z.record(z.string(), z.string()).optional(),
-	compat: OpenAICompatSchema.optional(),
-	contextPromotionTarget: z.string().min(1).optional(),
-	wireModelId: z.string().min(1).optional(),
-	requestTransform: RequestTransformSchema.optional(),
-});
+const ModelDefinitionSchema = z
+	.object({
+		id: z.string().min(1),
+		name: z.string().min(1).optional(),
+		api: z
+			.enum([
+				"openai-completions",
+				"openai-responses",
+				"openai-codex-responses",
+				"azure-openai-responses",
+				"anthropic-messages",
+				"bedrock-converse-stream",
+				"google-generative-ai",
+				"google-vertex",
+				"google-gemini-cli",
+				"ollama-chat",
+				"cursor-agent",
+			])
+			.optional(),
+		baseUrl: z.string().min(1).optional(),
+		reasoning: z.boolean().optional(),
+		thinking: ModelThinkingSchema.optional(),
+		input: z.array(z.enum(["text", "image"])).optional(),
+		cost: z
+			.object({
+				input: z.number(),
+				output: z.number(),
+				cacheRead: z.number(),
+				cacheWrite: z.number(),
+			})
+			.optional(),
+		premiumMultiplier: z.number().optional(),
+		contextWindow: z.number().optional(),
+		maxTokens: z.number().optional(),
+		headers: z.record(z.string(), z.string()).optional(),
+		compat: OpenAICompatSchema.optional(),
+		contextPromotionTarget: z.string().min(1).optional(),
+		wireModelId: z.string().min(1).optional(),
+		requestTransform: RequestTransformSchema.optional(),
+	})
+	.strict();
+
+export const ModelOverrideSchema = z
+	.object({
+		name: z.string().min(1).optional(),
+		reasoning: z.boolean().optional(),
+		thinking: ModelThinkingSchema.optional(),
+		input: z.array(z.enum(["text", "image"])).optional(),
+		cost: z
+			.object({
+				input: z.number().optional(),
+				output: z.number().optional(),
+				cacheRead: z.number().optional(),
+				cacheWrite: z.number().optional(),
+			})
+			.optional(),
+		premiumMultiplier: z.number().optional(),
+		contextWindow: z.number().optional(),
+		maxTokens: z.number().optional(),
+		headers: z.record(z.string(), z.string()).optional(),
+		compat: OpenAICompatSchema.optional(),
+		contextPromotionTarget: z.string().min(1).optional(),
+		wireModelId: z.string().min(1).optional(),
+		requestTransform: RequestTransformSchema.optional(),
+	})
+	.strict();
 
 export type ModelOverride = z.infer<typeof ModelOverrideSchema>;
 
@@ -145,49 +155,57 @@ export const ProviderAuthSchema = z.enum(["apiKey", "none", "oauth"]);
 export type ProviderAuthMode = z.infer<typeof ProviderAuthSchema>;
 export type ProviderDiscovery = z.infer<typeof ProviderDiscoverySchema>;
 
-const ProviderConfigSchema = z.object({
-	baseUrl: z.string().min(1).optional(),
-	apiKey: z.string().min(1).optional(),
-	apiKeyEnv: z.string().min(1).optional(),
-	api: z
-		.enum([
-			"openai-completions",
-			"openai-responses",
-			"openai-codex-responses",
-			"azure-openai-responses",
-			"anthropic-messages",
-			"google-generative-ai",
-			"google-vertex",
-		])
-		.optional(),
-	headers: z.record(z.string(), z.string()).optional(),
-	compat: OpenAICompatSchema.optional(),
-	authHeader: z.boolean().optional(),
-	auth: ProviderAuthSchema.optional(),
-	discovery: ProviderDiscoverySchema.optional(),
-	requestTransform: RequestTransformSchema.optional(),
-	models: z.array(ModelDefinitionSchema).optional(),
-	modelOverrides: z.record(z.string(), ModelOverrideSchema).optional(),
-	disableStrictTools: z.boolean().optional(),
-	/**
-	 * Streaming transport override. When set to `"pi-native"`, gjc dispatches
-	 * every model under this provider via the auth-gateway's
-	 * `POST /v1/pi/stream` endpoint instead of the per-provider SDK. The
-	 * provider's `baseUrl` must point at a compatible `gjc auth-gateway`
-	 * and `apiKey` must carry the gateway bearer.
-	 */
-	transport: z.literal("pi-native").optional(),
-});
+const ProviderConfigSchema = z
+	.object({
+		baseUrl: z.string().min(1).optional(),
+		apiKey: z.string().min(1).optional(),
+		apiKeyEnv: z.string().min(1).optional(),
+		api: z
+			.enum([
+				"openai-completions",
+				"openai-responses",
+				"openai-codex-responses",
+				"azure-openai-responses",
+				"anthropic-messages",
+				"bedrock-converse-stream",
+				"google-generative-ai",
+				"google-vertex",
+				"google-gemini-cli",
+				"ollama-chat",
+				"cursor-agent",
+			])
+			.optional(),
+		headers: z.record(z.string(), z.string()).optional(),
+		compat: OpenAICompatSchema.optional(),
+		authHeader: z.boolean().optional(),
+		auth: ProviderAuthSchema.optional(),
+		discovery: ProviderDiscoverySchema.optional(),
+		requestTransform: RequestTransformSchema.optional(),
+		models: z.array(ModelDefinitionSchema).optional(),
+		modelOverrides: z.record(z.string(), ModelOverrideSchema).optional(),
+		disableStrictTools: z.boolean().optional(),
+		/**
+		 * Streaming transport override. When set to `"pi-native"`, gjc dispatches
+		 * every model under this provider via the auth-gateway's
+		 * `POST /v1/pi/stream` endpoint instead of the per-provider SDK. The
+		 * provider's `baseUrl` must point at a compatible `gjc auth-gateway`
+		 * and `apiKey` must carry the gateway bearer.
+		 */
+		transport: z.literal("pi-native").optional(),
+	})
+	.strict();
 
 const EquivalenceConfigSchema = z.object({
 	overrides: z.record(z.string(), z.string().min(1)).optional(),
 	exclude: z.array(z.string().min(1)).optional(),
 });
 
-export const ModelsConfigSchema = z.object({
-	providers: z.record(z.string(), ProviderConfigSchema).optional(),
-	modelBindings: ModelBindingsSchema.optional(),
-	equivalence: EquivalenceConfigSchema.optional(),
-});
+export const ModelsConfigSchema = z
+	.object({
+		providers: z.record(z.string(), ProviderConfigSchema).optional(),
+		modelBindings: ModelBindingsSchema.optional(),
+		equivalence: EquivalenceConfigSchema.optional(),
+	})
+	.strict();
 
 export type ModelsConfig = z.infer<typeof ModelsConfigSchema>;

package/src/config/settings-schema.ts

@@ -901,30 +901,6 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	"loop.mode": {
-		type: "enum",
-		values: ["prompt", "compact", "reset"] as const,
-		default: "prompt",
-		ui: {
-			tab: "interaction",
-			label: "Loop Mode",
-			description: "What happens between /loop iterations before re-submitting the prompt",
-			options: [
-				{
-					value: "prompt",
-					label: "Prompt",
-					description: "Re-submit the prompt as a follow-up message (current behavior)",
-				},
-				{
-					value: "compact",
-					label: "Compact",
-					description: "Compact the session context, then re-submit the prompt",
-				},
-				{ value: "reset", label: "Reset", description: "Start a new session, then re-submit the prompt" },
-			],
-		},
-	},
-
 	// Input and startup
 	doubleEscapeAction: {
 		type: "enum",
@@ -2207,7 +2183,7 @@ export const SETTINGS_SCHEMA = {
 		ui: {
 			tab: "tasks",
 			label: "Goal Status In Footer",
-			description: "Show token budget alongside the goal indicator in the status line",
+			description: "Show goal usage alongside the goal indicator in the status line",
 		},
 	},
 

package/src/config.ts

@@ -20,7 +20,7 @@ const PROJECT_CONFIG_PRIORITY = [{ dir: CONFIG_DIR_NAME }, { dir: ".gemini" }];
  */
 export function getPackageDir(): string {
 	// Allow override via environment variable (useful for Nix/Guix where store paths tokenize poorly)
-	const envDir = process.env.PI_PACKAGE_DIR;
+	const envDir = process.env.GJC_PACKAGE_DIR ?? process.env.PI_PACKAGE_DIR;
 	if (envDir) {
 		return expandTilde(envDir);
 	}