@gajae-code/coding-agent 0.2.0 → 0.2.2

package/src/cli/args.ts

@@ -55,6 +55,15 @@ export interface Args {
 	unknownFlags: Map<string, boolean | string>;
 }
 
+function isStartupSlashCommandArg(arg: string | undefined): boolean {
+	return (
+		arg === "/provider" ||
+		arg?.startsWith("/provider:") === true ||
+		arg === "/provicer" ||
+		arg?.startsWith("/provicer:") === true
+	);
+}
+
 export function parseArgs(args: string[]): Args {
 	const result: Args = {
 		messages: [],
@@ -65,6 +74,11 @@ export function parseArgs(args: string[]): Args {
 	for (let i = 0; i < args.length; i++) {
 		let arg = args[i];
 
+		if (isStartupSlashCommandArg(arg)) {
+			result.messages.push(args.slice(i).join(" "));
+			break;
+		}
+
 		// Support --flag=value syntax (e.g. --tools=ask,read)
 		if (arg.startsWith("--") && arg.includes("=")) {
 			const eqIdx = arg.indexOf("=");
@@ -231,9 +245,10 @@ export function getExtraHelpText(): string {
   GJC_SLOW_MODEL              - Override slow/reasoning model (see --slow)
   GJC_PLAN_MODEL              - Override planning model (see --plan)
   GJC_NO_PTY                  - Disable PTY-based interactive bash execution
-  --tmux                       - Launch interactive startup inside tmux
+  --tmux                       - Launch interactive startup inside a new tmux session
+  gjc session                  - List, inspect, create, remove, or attach tagged GJC-managed tmux sessions
   GJC_LAUNCH_POLICY           - Launch policy for --tmux startup: tmux or direct
-  GJC_TMUX_SESSION            - tmux session name for default interactive startup (default: gajae_code)
+  GJC_TMUX_SESSION            - Explicit tmux session name override for --tmux startup
 
   For complete environment variable reference, see:
   ${chalk.dim("docs/environment-variables.md")}

package/src/cli/skills-cli.ts

@@ -0,0 +1,88 @@
+/**
+ * Handles `gjc skills` for inspecting bundled workflow skill definitions.
+ */
+import {
+	DEFAULT_GJC_DEFINITION_NAMES,
+	type EmbeddedDefaultGjcSkill,
+	getEmbeddedDefaultGjcSkills,
+} from "../defaults/gjc-defaults";
+
+export type SkillsAction = "list" | "read";
+
+export interface SkillsCommandArgs {
+	action: SkillsAction;
+	name?: string;
+	flags?: {
+		json?: boolean;
+	};
+}
+
+interface SkillsListEntry {
+	name: string;
+	description: string;
+	path: string;
+	source: string;
+}
+
+interface SkillsReadEntry extends SkillsListEntry {
+	content: string;
+}
+
+function getEmbeddedSkill(name: string): EmbeddedDefaultGjcSkill | undefined {
+	return getEmbeddedDefaultGjcSkills().find(skill => skill.name === name);
+}
+
+function listEmbeddedSkills(): SkillsListEntry[] {
+	return getEmbeddedDefaultGjcSkills().map(skill => ({
+		name: skill.name,
+		description: skill.description,
+		path: skill.filePath,
+		source: skill.source,
+	}));
+}
+
+function writeJson(value: unknown): void {
+	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function runSkillsCommand(cmd: SkillsCommandArgs): Promise<void> {
+	if (cmd.action === "list") {
+		const skills = listEmbeddedSkills();
+		if (cmd.flags?.json) {
+			writeJson({ skills });
+			return;
+		}
+		for (const skill of skills) {
+			process.stdout.write(`${skill.name}\t${skill.description}\t${skill.path}\n`);
+		}
+		return;
+	}
+
+	const name = cmd.name?.trim();
+	if (!name) {
+		process.stderr.write(`error: skill name is required for read (${DEFAULT_GJC_DEFINITION_NAMES.join(", ")})\n`);
+		process.exitCode = 1;
+		return;
+	}
+
+	const skill = getEmbeddedSkill(name);
+	if (!skill) {
+		process.stderr.write(`error: unknown embedded skill "${name}" (${DEFAULT_GJC_DEFINITION_NAMES.join(", ")})\n`);
+		process.exitCode = 1;
+		return;
+	}
+
+	const entry: SkillsReadEntry = {
+		name: skill.name,
+		description: skill.description,
+		path: skill.filePath,
+		source: skill.source,
+		content: skill.content,
+	};
+	if (cmd.flags?.json) {
+		writeJson(entry);
+		return;
+	}
+	process.stdout.write(skill.content);
+	if (!skill.content.endsWith("\n")) process.stdout.write("\n");
+}

package/src/cli.ts

@@ -31,12 +31,18 @@ process.title = APP_NAME;
 
 const commands: CommandEntry[] = [
 	{ name: "codex-native-hook", load: () => import("./commands/codex-native-hook").then(m => m.default) },
-	{ name: "question", load: () => import("./commands/question").then(m => m.default) },
 	{ name: "state", load: () => import("./commands/state").then(m => m.default) },
 	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
+	{ name: "skills", load: () => import("./commands/skills").then(m => m.default) },
+	{ name: "session", load: () => import("./commands/session").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: "ralplan", load: () => import("./commands/ralplan").then(m => m.default) },
+	{
+		name: "contribute-pr",
+		aliases: ["contribution-prep"],
+		load: () => import("./commands/contribution-prep").then(m => m.default),
+	},
 	{ name: "deep-interview", load: () => import("./commands/deep-interview").then(m => m.default) },
 	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },
 ];

package/src/commands/contribution-prep.ts

@@ -0,0 +1,41 @@
+import { Command, Flags } from "@gajae-code/utils/cli";
+import { prepareContributionPrep } from "../session/contribution-prep";
+
+function writeText(lines: string[]): void {
+	process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+export default class ContributionPrep extends Command {
+	static description = "Dump redacted context and prepare a fresh contribute-pr worker prompt";
+	static strict = false;
+
+	static flags = {
+		"no-spawn": Flags.boolean({ description: "Only write artifacts; do not spawn a fresh GJC worker" }),
+		"source-session-id": Flags.string({ description: "Source session id to record in the manifest" }),
+		"artifact-root": Flags.string({ description: "Directory where contribute-pr artifacts are written" }),
+	};
+
+	static examples = ["gjc contribute-pr", "gjc contribute-pr --no-spawn"];
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(ContributionPrep);
+		const cwd = process.cwd();
+		const result = await prepareContributionPrep(
+			{
+				sessionId: flags["source-session-id"] ?? "cli",
+				cwd,
+				messages: [],
+			},
+			{
+				spawnWorker: !flags["no-spawn"],
+				artifactRoot: flags["artifact-root"],
+			},
+		);
+		writeText([
+			"Contribution prep artifacts written.",
+			`Manifest: ${result.manifestPath}`,
+			`Worker prompt: ${result.workerPromptPath}`,
+			`Spawned worker: ${result.spawned ? "yes" : "no"}`,
+		]);
+	}
+}

package/src/commands/deep-interview.ts

@@ -1,31 +1,15 @@
 import { Command } from "@gajae-code/utils/cli";
-import { syncSkillActiveState } from "../skill-state/active-state";
-import { runGjcRuntimeBridgeWithHudSidecar } from "./gjc-runtime-bridge";
+import { runNativeDeepInterviewCommand } from "../gjc-runtime/deep-interview-runtime";
 
 export default class DeepInterview extends Command {
-	static description = "Run private GJC deep-interview workflow commands";
+	static description = "Run native GJC deep-interview workflow";
 	static strict = false;
-	static examples = ["$ gjc deep-interview --help"];
+	static examples = ['$ gjc deep-interview --standard "<idea>"'];
 
 	async run(): Promise<void> {
-		const cwd = process.cwd();
-		const result = await runGjcRuntimeBridgeWithHudSidecar("deep-interview", this.argv, {
-			cwd,
-			sidecarSkill: "deep-interview",
-			onHudPayload: payload =>
-				syncSkillActiveState({
-					cwd,
-					skill: "deep-interview",
-					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 runNativeDeepInterviewCommand(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/launch.ts

@@ -155,7 +155,16 @@ export default class Index extends Command {
 			setProjectDir(launch.cwd);
 		}
 		const launchParsed = parseArgs(launch.args);
-		if (launchDefaultTmuxIfNeeded({ parsed: launchParsed, rawArgs: launch.args, cwd: launch.cwd })) return;
+		if (
+			launchDefaultTmuxIfNeeded({
+				parsed: launchParsed,
+				rawArgs: launch.args,
+				cwd: launch.cwd,
+				worktreeBranch: launch.worktree.enabled && !launch.worktree.detached ? launch.worktree.branchName : null,
+				project: launch.worktree.enabled ? launch.worktree.repoRoot : launch.cwd,
+			})
+		)
+			return;
 		await runRootCommand(launchParsed, launch.args);
 	}
 }

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/skills.ts

@@ -0,0 +1,48 @@
+/**
+ * Inspect bundled workflow skills.
+ */
+import { Args, Command, Flags, renderCommandHelp } from "@gajae-code/utils/cli";
+import { runSkillsCommand, type SkillsAction, type SkillsCommandArgs } from "../cli/skills-cli";
+
+const ACTIONS: SkillsAction[] = ["list", "read"];
+
+export default class Skills extends Command {
+	static description = "Inspect bundled GJC workflow skills";
+
+	static args = {
+		action: Args.string({
+			description: "Skills action",
+			required: false,
+			options: ACTIONS,
+		}),
+		name: Args.string({
+			description: "Bundled skill name to read",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+	};
+
+	static examples = [
+		"# List bundled workflow skills\n  gjc skills list",
+		"# Read an embedded workflow skill without requiring .gjc files\n  gjc skills read ultragoal",
+		"# Machine-readable embedded skill content\n  gjc skills read ralplan --json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Skills);
+		if (!args.action) {
+			renderCommandHelp("gjc", "skills", Skills);
+			return;
+		}
+
+		const cmd: SkillsCommandArgs = {
+			action: args.action as SkillsAction,
+			name: args.name,
+			flags: { json: flags.json },
+		};
+		await runSkillsCommand(cmd);
+	}
+}

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/commit/agentic/index.ts

@@ -31,6 +31,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	process.stdout.write("● Resolving model...\n");
 	const modelRegistry = new ModelRegistry(authStorage);
 	await modelRegistry.refresh();
+	modelRegistry.applyConfiguredModelBindings(settings);
 	const stagedFilesPromise = (async () => {
 		let stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
 		if (stagedFiles.length === 0) {

package/src/commit/pipeline.ts

@@ -45,6 +45,7 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 	const authStorage = await discoverAuthStorage();
 	const modelRegistry = new ModelRegistry(authStorage);
 	await modelRegistry.refresh();
+	modelRegistry.applyConfiguredModelBindings(settings);
 
 	const {
 		model: primaryModel,