@gajae-code/coding-agent 0.6.4 → 0.7.0

package/src/commands/migrate.ts

@@ -0,0 +1,46 @@
+/**
+ * Import MCP servers and skills from other coding agents into GJC.
+ */
+import { Command, Flags } from "@gajae-code/utils/cli";
+import { type MigrateCommandArgs, runMigrateCommand } from "../cli/migrate-cli";
+
+export default class Migrate extends Command {
+	static description = "Import MCP servers and skills from Claude Code, Codex, or OpenCode";
+
+	static examples = [
+		"gjc migrate --from claude-code",
+		"gjc migrate --from codex --from opencode",
+		"gjc migrate --from all --dry-run --json",
+		"gjc migrate --from claude-code --project --force",
+	];
+
+	static flags = {
+		from: Flags.string({
+			description: "Source agent to import from (repeatable): claude-code | codex | opencode | all",
+			multiple: true,
+			required: true,
+		}),
+		project: Flags.boolean({
+			description: "Write to the project scope (./.gjc) instead of the user scope (~/.gjc)",
+			default: false,
+		}),
+		force: Flags.boolean({
+			description: "Overwrite existing skills/MCP servers instead of skipping them",
+			default: false,
+		}),
+		"dry-run": Flags.boolean({ description: "Preview the migration without writing anything", default: false }),
+		json: Flags.boolean({ char: "j", description: "Emit a machine-readable JSON report", default: false }),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Migrate);
+		const cmd: MigrateCommandArgs = {
+			from: flags.from ?? [],
+			project: flags.project,
+			force: flags.force,
+			dryRun: flags["dry-run"],
+			json: flags.json,
+		};
+		await runMigrateCommand(cmd);
+	}
+}

package/src/commands/notify.ts

@@ -0,0 +1,61 @@
+/**
+ * Configure Telegram notifications.
+ */
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { type NotifyAction, type NotifyCommandArgs, runNotifyCommand } from "../cli/notify-cli";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: NotifyAction[] = ["setup", "status", "daemon-internal"];
+
+export default class Notify extends Command {
+	static description = "Configure Telegram notifications";
+
+	static args = {
+		action: Args.string({
+			description: "Notify action",
+			required: false,
+			options: ACTIONS,
+		}),
+		extra: Args.string({
+			description: "Additional internal args",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		smoke: Flags.boolean({ description: "Run hidden daemon smoke" }),
+		token: Flags.string({ description: "Telegram bot token (non-interactive setup)" }),
+		"chat-id": Flags.string({ description: "Telegram chat id to pair (non-interactive setup)" }),
+		redact: Flags.boolean({ description: "Enable redaction of remote notification content" }),
+		"owner-id": Flags.string({ description: "Internal: daemon owner id" }),
+		"agent-dir": Flags.string({ description: "Internal: agent dir for the daemon" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Notify);
+		const action = (args.action ?? "status") as NotifyAction;
+		const extra = Array.isArray(args.extra) ? args.extra : args.extra ? [args.extra] : [];
+		const flagRec = flags as Record<string, unknown>;
+		const ownerId = flagRec["owner-id"] as string | undefined;
+		const agentDir = flagRec["agent-dir"] as string | undefined;
+		const rawArgs = [
+			...(flags.smoke ? ["--smoke"] : []),
+			...(ownerId ? ["--owner-id", ownerId] : []),
+			...(agentDir ? ["--agent-dir", agentDir] : []),
+			...extra,
+		];
+
+		const cmd: NotifyCommandArgs = {
+			action,
+			smoke: flags.smoke,
+			rawArgs,
+			token: flags.token as string | undefined,
+			chatId: (flags as Record<string, unknown>)["chat-id"] as string | undefined,
+			redact: Boolean(flags.redact),
+		};
+
+		await initTheme();
+		await runNotifyCommand(cmd);
+	}
+}

package/src/commands/setup.ts

@@ -5,7 +5,17 @@ import { Args, Command, Flags } from "@gajae-code/utils/cli";
 import { runSetupCommand, type SetupCommandArgs, type SetupComponent } from "../cli/setup-cli";
 import { initTheme } from "../modes/theme/theme";
 
-const COMPONENTS: SetupComponent[] = ["credentials", "defaults", "hermes", "hooks", "provider", "python", "stt"];
+const COMPONENTS: SetupComponent[] = [
+	"claude",
+	"codex",
+	"credentials",
+	"defaults",
+	"hermes",
+	"hooks",
+	"provider",
+	"python",
+	"stt",
+];
 
 export default class Setup extends Command {
 	static description = "Install GJC defaults or optional feature dependencies";

package/src/commands/state.ts

@@ -2,7 +2,8 @@ import { Command } from "@gajae-code/utils/cli";
 import { runNativeStateCommand } from "../gjc-runtime/state-runtime";
 
 export default class State extends Command {
-	static description = "Read or update GJC workflow state receipts under .gjc/state";
+	static description =
+		"Read or update current-session GJC workflow state receipts under .gjc/_session-{sessionid}/state";
 	static strict = false;
 	static examples = [
 		'$ gjc state read --input \'{"mode":"deep-interview"}\' --json',

package/src/commands/team.ts

@@ -75,7 +75,7 @@ function parseInputFlag(argv: string[]): Record<string, unknown> {
 
 export default class Team extends Command {
 	static description =
-		"Run native GJC tmux team orchestration from inside an existing tmux/GJC --tmux session; --dry-run writes ephemeral .gjc/state/team state only";
+		"Run native GJC tmux team orchestration from inside an existing tmux/GJC --tmux session; --dry-run writes ephemeral .gjc/_session-{sessionid}/state/team state only";
 	static strict = false;
 
 	static args = {
@@ -89,7 +89,7 @@ export default class Team extends Command {
 		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
 		"dry-run": Flags.boolean({
 			description:
-				"Create ephemeral .gjc/state/team state without starting tmux panes; do not commit generated state",
+				"Create ephemeral .gjc/_session-{sessionid}/state/team state without starting tmux panes; do not commit generated state",
 			default: false,
 		}),
 	};
@@ -210,7 +210,11 @@ 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"] : []),
+			...(dryRun
+				? [
+						"dry-run: wrote ephemeral .gjc/_session-{sessionid}/state/team state only; do not commit generated .gjc state",
+					]
+				: []),
 		]);
 	}
 }

package/src/config/model-profile-activation.ts

@@ -17,6 +17,8 @@ type ModelProfileActivationSession = Pick<AgentSession, "model" | "thinkingLevel
 	setModelTemporary?: AgentSession["setModelTemporary"];
 	setActiveModelProfile?: (name: string | undefined) => void;
 	getActiveModelProfile?: () => string | undefined;
+	getSessionDefaultModelSelector?: () => string | undefined;
+	recordResumeDefaultModel?: (selector: string) => void;
 };
 
 export interface PrepareModelProfileActivationOptions {
@@ -43,10 +45,20 @@ export interface PreparedModelProfileActivation {
 	previousModel: Model<Api> | undefined;
 	previousThinkingLevel: ThinkingLevel | undefined;
 	previousAgentModelOverrides: Record<string, string>;
+	previousModelRoles: Record<string, string>;
 	defaultModel: Model<Api> | undefined;
 	defaultThinkingLevel: ThinkingLevel | undefined;
+	modelRoles: Record<string, string>;
 	agentModelOverrides: Record<string, string>;
 	previousActiveModelProfile: string | undefined;
+	/**
+	 * The session resume default ("provider/id") captured BEFORE activation —
+	 * the model resume would restore prior to this profile. Snapshotted
+	 * separately from `previousModel` (the live runtime model, which may be a
+	 * transient switch) so a failed-activation rollback restores the correct
+	 * resume default without promoting a transient model to it.
+	 */
+	previousSessionDefaultModel: string | undefined;
 }
 
 export function formatModelProfileCredentialError(profileName: string, providers: readonly string[]): string {
@@ -87,14 +99,24 @@ function rewriteSelectorProvider(
 }
 
 function rewriteBindingsProviders(
-	bindings: { defaultSelector?: string; agentModelOverrides: Record<string, string> },
+	bindings: {
+		defaultSelector?: string;
+		modelRoles: Record<string, string>;
+		agentModelOverrides: Record<string, string>;
+	},
 	authenticatedProviders: ReadonlySet<string>,
 	alternativeGroups: readonly (readonly string[])[],
-): { defaultSelector?: string; agentModelOverrides: Record<string, string> } {
+): { defaultSelector?: string; modelRoles: Record<string, string>; agentModelOverrides: Record<string, string> } {
 	return {
 		defaultSelector: bindings.defaultSelector
 			? rewriteSelectorProvider(bindings.defaultSelector, authenticatedProviders, alternativeGroups)
 			: undefined,
+		modelRoles: Object.fromEntries(
+			Object.entries(bindings.modelRoles).map(([role, sel]) => [
+				role,
+				rewriteSelectorProvider(sel, authenticatedProviders, alternativeGroups),
+			]),
+		),
 		agentModelOverrides: Object.fromEntries(
 			Object.entries(bindings.agentModelOverrides).map(([role, sel]) => [
 				role,
@@ -165,6 +187,18 @@ export async function prepareModelProfileActivation(
 		);
 	}
 
+	const modelRoles: Record<string, string> = {};
+	for (const [role, selector] of Object.entries(bindings.modelRoles) as [GjcModelAssignmentTargetId, string][]) {
+		const resolved = resolveModelRoleValue(selector, availableModels, {
+			settings: options.settings as Settings,
+			modelRegistry: options.modelRegistry,
+		});
+		if (!resolved.model) {
+			throw new Error(`Model profile "${options.profileName}" ${role} selector did not resolve: ${selector}`);
+		}
+		modelRoles[role] = formatClampedModelSelector(selector, resolved.model);
+	}
+
 	const agentModelOverrides: Record<string, string> = {};
 	for (const [role, selector] of Object.entries(bindings.agentModelOverrides) as [
 		GjcModelAssignmentTargetId,
@@ -187,10 +221,13 @@ export async function prepareModelProfileActivation(
 		previousModel: options.session.model,
 		previousThinkingLevel: options.session.thinkingLevel,
 		previousAgentModelOverrides: { ...options.settings.get("task.agentModelOverrides") },
+		previousModelRoles: { ...options.settings.get("modelRoles") },
 		defaultModel: resolvedDefault?.model,
 		defaultThinkingLevel: resolvedDefault?.thinkingLevel,
+		modelRoles,
 		agentModelOverrides,
 		previousActiveModelProfile: options.session.getActiveModelProfile?.(),
+		previousSessionDefaultModel: options.session.getSessionDefaultModelSelector?.(),
 	};
 }
 
@@ -201,17 +238,29 @@ export async function applyPreparedModelProfileActivation(
 	const previousModel = prepared.previousModel;
 	const previousThinkingLevel = prepared.previousThinkingLevel;
 	const previousAgentModelOverrides = prepared.previousAgentModelOverrides;
+	const previousModelRoles = prepared.previousModelRoles;
 	const previousPersistedDefault = prepared.settings.get("modelProfile.default");
 	const previousActiveModelProfile = prepared.previousActiveModelProfile;
+	const previousSessionDefaultModel = prepared.previousSessionDefaultModel;
 	let modelChanged = false;
 	let overridesChanged = false;
 	let defaultChanged = false;
+	let modelRolesChanged = false;
 
 	try {
 		if (prepared.defaultModel) {
-			await prepared.session.setModelTemporary(prepared.defaultModel, prepared.defaultThinkingLevel);
+			await prepared.session.setModelTemporary(prepared.defaultModel, prepared.defaultThinkingLevel, {
+				persistAsSessionDefault: true,
+			});
 			modelChanged = true;
 		}
+		if (Object.keys(prepared.modelRoles).length > 0) {
+			prepared.settings.override("modelRoles", {
+				...prepared.settings.get("modelRoles"),
+				...prepared.modelRoles,
+			});
+			modelRolesChanged = true;
+		}
 		if (Object.keys(prepared.agentModelOverrides).length > 0) {
 			prepared.settings.override("task.agentModelOverrides", {
 				...prepared.settings.get("task.agentModelOverrides"),
@@ -229,12 +278,32 @@ export async function applyPreparedModelProfileActivation(
 		if (defaultChanged) {
 			prepared.settings.set("modelProfile.default", previousPersistedDefault);
 		}
+		if (modelRolesChanged) {
+			prepared.settings.override("modelRoles", previousModelRoles);
+		}
 		if (overridesChanged) {
 			prepared.settings.override("task.agentModelOverrides", previousAgentModelOverrides);
 		}
 		prepared.session.setActiveModelProfile?.(previousActiveModelProfile);
-		if (modelChanged && previousModel) {
-			await prepared.session.setModelTemporary(previousModel, previousThinkingLevel);
+		if (modelChanged) {
+			// Runtime rolls back to the pre-activation live model. That model may
+			// itself be a transient retry/fallback/context-promotion/plan switch,
+			// so it is recorded as role:"temporary" (NOT the resume default) to
+			// preserve the issue #849 protection.
+			if (previousModel) {
+				await prepared.session.setModelTemporary(previousModel, previousThinkingLevel);
+			}
+			// The happy path already appended the profile main model as the resume
+			// default (role:"default"). Re-assert the pre-activation resume default
+			// so a failed activation does not poison future resume. Fall back to the
+			// live model only when there was no explicit pre-activation default
+			// (nothing to protect). Append-only — never touches the runtime model.
+			const restoreDefaultSelector =
+				previousSessionDefaultModel ??
+				(previousModel ? `${previousModel.provider}/${previousModel.id}` : undefined);
+			if (restoreDefaultSelector) {
+				prepared.session.recordResumeDefaultModel?.(restoreDefaultSelector);
+			}
 		}
 		throw error;
 	}

package/src/config/model-profiles.ts

@@ -23,7 +23,8 @@ export interface ModelProfileDefinition {
 
 export interface ResolvedProfileBinding {
 	defaultSelector?: string;
-	agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default">, string>>;
+	modelRoles: Partial<Record<"vision", string>>;
+	agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default" | "vision">, string>>;
 }
 
 function parseModelSelectorProvider(selector: string): string | undefined {
@@ -56,7 +57,7 @@ export function aggregateModelProfileRequiredProviders(
 const profile = (
 	name: string,
 	requiredProviders: string[],
-	modelMapping: Record<ModelProfileRole, string>,
+	modelMapping: Partial<Record<ModelProfileRole, string>>,
 	alternativeProviderGroups?: readonly (readonly string[])[],
 ): ModelProfileDefinition => ({
 	name,
@@ -382,13 +383,15 @@ export function mergeModelProfiles(userProfiles?: ModelsConfig["profiles"]): Map
 }
 
 export function resolveProfileBindings(definition: ModelProfileDefinition): ResolvedProfileBinding {
-	const { default: defaultSelector, executor, architect, planner, critic } = definition.modelMapping;
+	const { default: defaultSelector, vision, executor, architect, planner, critic } = definition.modelMapping;
+	const modelRoles: ResolvedProfileBinding["modelRoles"] = {};
+	if (vision !== undefined) modelRoles.vision = vision;
 	const agentModelOverrides: ResolvedProfileBinding["agentModelOverrides"] = {};
 	if (executor !== undefined) agentModelOverrides.executor = executor;
 	if (architect !== undefined) agentModelOverrides.architect = architect;
 	if (planner !== undefined) agentModelOverrides.planner = planner;
 	if (critic !== undefined) agentModelOverrides.critic = critic;
-	return { defaultSelector, agentModelOverrides };
+	return { defaultSelector, modelRoles, agentModelOverrides };
 }
 
 export function formatAvailableProfileNames(profiles: ReadonlyMap<string, ModelProfileDefinition>): string {

package/src/config/model-registry.ts

@@ -70,7 +70,7 @@ export function isAuthenticated(apiKey: string | undefined | null): apiKey is st
 	return Boolean(apiKey) && apiKey !== kNoAuth;
 }
 
-export type ModelRole = "default";
+export type ModelRole = "default" | "vision";
 
 export interface ModelRoleInfo {
 	tag?: string;
@@ -80,11 +80,12 @@ export interface ModelRoleInfo {
 
 export const MODEL_ROLES: Record<ModelRole, ModelRoleInfo> = {
 	default: { tag: "DEFAULT", name: "Default", color: "success" },
+	vision: { tag: "VISION", name: "Vision", color: "accent" },
 };
 
-export const MODEL_ROLE_IDS: ModelRole[] = ["default"];
+export const MODEL_ROLE_IDS: ModelRole[] = ["default", "vision"];
 
-export type GjcModelAssignmentTargetId = "default" | "executor" | "architect" | "planner" | "critic";
+export type GjcModelAssignmentTargetId = "default" | "vision" | "executor" | "architect" | "planner" | "critic";
 
 export interface GjcModelAssignmentTargetInfo extends ModelRoleInfo {
 	id: GjcModelAssignmentTargetId;
@@ -93,6 +94,7 @@ export interface GjcModelAssignmentTargetInfo extends ModelRoleInfo {
 
 export const GJC_MODEL_ASSIGNMENT_TARGET_IDS: GjcModelAssignmentTargetId[] = [
 	"default",
+	"vision",
 	"executor",
 	"architect",
 	"planner",
@@ -101,6 +103,7 @@ export const GJC_MODEL_ASSIGNMENT_TARGET_IDS: GjcModelAssignmentTargetId[] = [
 
 export const GJC_MODEL_ASSIGNMENT_TARGETS: Record<GjcModelAssignmentTargetId, GjcModelAssignmentTargetInfo> = {
 	default: { id: "default", tag: "DEFAULT", name: "Default", color: "success", settingsPath: "modelRoles" },
+	vision: { id: "vision", tag: "VISION", name: "Vision", color: "accent", settingsPath: "modelRoles" },
 	executor: {
 		id: "executor",
 		tag: "EXECUTOR",

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

@@ -81,7 +81,7 @@ const ModelBindingsSchema = z.object({
 	modelRoles: z.record(z.string(), z.string().min(1)).optional(),
 	agentModelOverrides: z.record(z.string(), z.string().min(1)).optional(),
 });
-export const ProfileRoleSchema = z.enum(["default", "executor", "architect", "planner", "critic"]);
+export const ProfileRoleSchema = z.enum(["default", "vision", "executor", "architect", "planner", "critic"]);
 
 function isValidProfileModelSelector(value: string): boolean {
 	if (value.includes(",")) return false;

package/src/config/settings-schema.ts

@@ -254,6 +254,22 @@ export const SETTINGS_SCHEMA = {
 	"auth.broker.url": { type: "string", default: undefined },
 	"auth.broker.token": { type: "string", default: undefined },
 
+	// Notifications (Telegram bundled reference client)
+	"notifications.enabled": { type: "boolean", default: false },
+	"notifications.telegram.botToken": { type: "string", default: undefined },
+	"notifications.telegram.chatId": { type: "string", default: undefined },
+	"notifications.redact": { type: "boolean", default: false },
+	"notifications.verbosity": {
+		type: "string",
+		default: "lean",
+		validate: (value: string) => value === "lean" || value === "verbose",
+	},
+	"notifications.daemon.idleTimeoutMs": {
+		type: "number",
+		default: 60000,
+		validate: (value: number) => Number.isFinite(value) && value > 0,
+	},
+
 	autoResume: {
 		type: "boolean",
 		default: false,
@@ -3155,6 +3171,18 @@ export interface ShellMinimizerSettings {
 	maxCaptureBytes: number;
 }
 
+export interface NotificationsSettings {
+	enabled: boolean;
+	telegram: {
+		botToken: string | undefined;
+		chatId: string | undefined;
+	};
+	redact: boolean;
+	daemon: {
+		idleTimeoutMs: number;
+	};
+}
+
 /** Map group prefix -> typed settings interface */
 export interface GroupTypeMap {
 	compaction: CompactionSettings;
@@ -3173,6 +3201,7 @@ export interface GroupTypeMap {
 	modelTags: ModelTagsSettings;
 	cycleOrder: string[];
 	shellMinimizer: ShellMinimizerSettings;
+	notifications: NotificationsSettings;
 }
 
 export type GroupPrefix = keyof GroupTypeMap;

package/src/coordinator/contract.ts

@@ -17,6 +17,9 @@ export const COORDINATOR_MCP_TOOL_NAMES = [
 	"gjc_coordinator_read_turn",
 	"gjc_coordinator_await_turn",
 	"gjc_coordinator_report_status",
+	"gjc_delegate_plan",
+	"gjc_delegate_execute",
+	"gjc_delegate_team",
 ] as const;
 
 export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/src/coordinator-mcp/policy.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { coordinatorMcpStateRoot, gjcRoot } from "../gjc-runtime/session-layout";
 
 export type CoordinatorMutationClass = "sessions" | "questions" | "reports";
 
@@ -73,9 +74,16 @@ function cleanScope(value: string | undefined): string | null {
 	return trimmed.replace(/[^a-zA-Z0-9_.-]+/g, "-").slice(0, 100) || null;
 }
 
+function defaultCoordinatorMcpStateRoot(cwd: string, gjcSessionId?: string): string {
+	return gjcSessionId
+		? coordinatorMcpStateRoot(cwd, gjcSessionId)
+		: path.join(gjcRoot(cwd), "state", "coordinator-mcp");
+}
+
 export function buildCoordinatorMcpConfig(env: NodeJS.ProcessEnv = process.env): CoordinatorMcpConfig {
-	const stateRoot =
-		env.GJC_COORDINATOR_MCP_STATE_ROOT?.trim() || path.join(process.cwd(), ".gjc", "state", "coordinator-mcp");
+	const stateRootOverride = env.GJC_COORDINATOR_MCP_STATE_ROOT?.trim();
+	const gjcSessionId = env.GJC_SESSION_ID?.trim();
+	const stateRoot = stateRootOverride || defaultCoordinatorMcpStateRoot(process.cwd(), gjcSessionId);
 	return {
 		allowedRoots: parseRootList(env.GJC_COORDINATOR_MCP_WORKDIR_ROOTS).map(root => path.resolve(root)),
 		mutationClasses: parseMutationClasses(