@gajae-code/coding-agent 0.6.4 → 0.7.0

package/dist/types/session/agent-session.d.ts

@@ -71,7 +71,7 @@ import { type AgentRegistry } from "../registry/agent-registry";
 import { type DiscoverableMCPSearchIndex, type DiscoverableMCPTool } from "../runtime-mcp/discoverable-tool-metadata";
 import { type SecretObfuscator } from "../secrets/obfuscator";
 import { type DiscoverableTool, type DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
-import type { ToolSession } from "../tools";
+import type { AskAnswerSource, ToolSession } from "../tools";
 import type { CheckpointState } from "../tools/checkpoint";
 import { type TodoItem, type TodoPhase } from "../tools/todo-write";
 import type { ClientBridge } from "./client-bridge";
@@ -128,6 +128,9 @@ export type AgentSessionEvent = AgentEvent | {
 } | {
     type: "irc_message";
     message: CustomMessage;
+} | {
+    type: "subagent_steer_message";
+    message: CustomMessage;
 } | {
     type: "notice";
     level: "info" | "warning" | "error";
@@ -558,6 +561,7 @@ export declare class AgentSession {
     getGoalModeState(): GoalModeState | undefined;
     setGoalModeState(state: GoalModeState | undefined): void;
     getWorkflowGateEmitter(): WorkflowGateEmitter | undefined;
+    getAskAnswerSource(): AskAnswerSource | undefined;
     setWorkflowGateEmitter(emitter: WorkflowGateEmitter | undefined): void;
     get goalRuntime(): GoalRuntime;
     markPlanReferenceSent(): void;
@@ -713,12 +717,38 @@ export declare class AgentSession {
     }): Promise<void>;
     setActiveModelProfile(name: string | undefined): void;
     getActiveModelProfile(): string | undefined;
+    /**
+     * The model selector ("provider/id") that resume restores as the session
+     * default — the latest session-log `model_change` with role="default".
+     * Model-profile activation snapshots this before mutating the session so a
+     * failed-activation rollback can restore the pre-activation resume default
+     * instead of promoting a transient runtime model to the resume default.
+     */
+    getSessionDefaultModelSelector(): string | undefined;
+    /**
+     * Re-assert the session resume default ("provider/id") in the session log
+     * WITHOUT touching the live runtime model. Appends a `model_change` with
+     * role="default"; never writes to global settings (apply-for-this-session
+     * semantics). Used by model-profile activation rollback to neutralize the
+     * profile main model the failed activation already recorded as the default.
+     */
+    recordResumeDefaultModel(selector: string): void;
     /**
      * Set model temporarily (for this session only).
      * Validates API key, saves to session log but NOT to settings.
+     *
+     * The change is recorded in the session log as `role: "temporary"` by
+     * default, which means it is NOT restored as the session default on resume —
+     * transient retry/fallback/context-promotion/plan switches must not clobber
+     * the user's explicit pick (issue #849). Model-profile activation passes
+     * `persistAsSessionDefault: true` so the profile's main model becomes the
+     * session default and survives resume, while still not being written to
+     * global settings (new sessions keep the global default).
      * @throws Error if no API key available for the model
      */
-    setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel): Promise<void>;
+    setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel, options?: {
+        persistAsSessionDefault?: boolean;
+    }): Promise<void>;
     /**
      * Cycle to next/previous model.
      * Uses scoped models (from --models flag) if available, otherwise all available models.
@@ -946,6 +976,13 @@ export declare class AgentSession {
      * Does not persist the record to history. Public so other sessions can forward.
      */
     emitIrcRelayObservation(record: CustomMessage): void;
+    emitSubagentSteerObservation(args: {
+        from: string;
+        to: string;
+        body: string;
+        timestamp?: number;
+    }): void;
+    emitSubagentSteerRelayObservation(record: CustomMessage): void;
     /**
      * Run a single ephemeral side-channel turn against this session's current
      * model + system prompt + history.  No tools are used; the side request

package/dist/types/session/auth-storage.d.ts

@@ -2,5 +2,5 @@
  * Re-exports from @gajae-code/ai.
  * All credential storage types and the AuthStorage class now live in the ai package.
  */
-export type { ApiKeyCredential, AuthCredential, AuthCredentialEntry, AuthCredentialStore, AuthStorageData, AuthStorageOptions, OAuthCredential, SerializedAuthStorage, StoredAuthCredential, } from "@gajae-code/ai";
+export type { ApiKeyCredential, AuthCredential, AuthCredentialEntry, AuthCredentialIfAbsentReason, AuthCredentialIfAbsentResult, AuthCredentialIfAbsentSnapshotResult, AuthCredentialStore, AuthStorageData, AuthStorageOptions, OAuthCredential, SerializedAuthStorage, StoredAuthCredential, } from "@gajae-code/ai";
 export { AuthBrokerClient, AuthStorage, REMOTE_REFRESH_SENTINEL, RemoteAuthCredentialStore, SqliteAuthCredentialStore, } from "@gajae-code/ai";

package/dist/types/setup/credential-auto-import.d.ts

@@ -0,0 +1,63 @@
+import type { AuthCredentialIfAbsentReason, AuthCredentialIfAbsentSnapshotResult, AuthStorage } from "@gajae-code/ai";
+import type { ModelRegistry } from "../config/model-registry";
+import { type CredentialDiscoveryResult, type CredentialOrigin, type DiscoveryOptions, type ImportableCredential } from "./credential-import";
+export declare const CREDENTIAL_AUTO_IMPORT_ROTATION_WARNING = "Refreshing in gjc may log out the Claude/Codex CLI because OAuth refresh tokens can rotate.";
+export type CredentialAutoImportSourceLabel = "claude-code-file" | "claude-code-keychain" | "codex-file";
+export type CredentialAutoImportTrigger = "startup" | "bare-login" | "setup-cli";
+export declare function getCredentialAutoImportStatePath(agentDir?: string): string;
+export declare function readCredentialImportMarker(agentDir?: string): Promise<string | undefined>;
+export declare function writeCredentialImportMarker(version: string, agentDir?: string): Promise<boolean>;
+export declare enum CredentialAutoImportFailureClass {
+    DiscoveryUnavailable = "discovery-unavailable",
+    SourceUnreadable = "source-unreadable",
+    SourceMalformed = "source-malformed",
+    KeychainDenied = "keychain-denied",
+    WriteInvalid = "write-invalid",
+    WriteConflict = "write-conflict",
+    BrokerUnavailable = "broker-unavailable",
+    BrokerUnsupported = "broker-unsupported",
+    Unknown = "unknown"
+}
+export interface CredentialAutoImportSkipped {
+    credential: ImportableCredential;
+    reason: AuthCredentialIfAbsentReason;
+    entries: AuthCredentialIfAbsentSnapshotResult["entries"];
+}
+export interface CredentialAutoImportFailure {
+    credential?: ImportableCredential;
+    origin?: CredentialOrigin;
+    source?: string;
+    failureClass: CredentialAutoImportFailureClass;
+}
+export interface CredentialAutoImportResult {
+    imported: ImportableCredential[];
+    skipped: CredentialAutoImportSkipped[];
+    failures: CredentialAutoImportFailure[];
+    discovered: boolean;
+    discovery?: CredentialDiscoveryResult;
+    globalDiscoveryFailure?: CredentialAutoImportFailure;
+}
+export type CredentialAutoImportAuthStorage = Pick<AuthStorage, "importCredentialIfAbsent">;
+export interface CredentialAutoImportOptions {
+    authStorage: CredentialAutoImportAuthStorage;
+    discover?: (options?: DiscoveryOptions) => Promise<CredentialDiscoveryResult>;
+    discoveryOptions?: DiscoveryOptions;
+    trigger: CredentialAutoImportTrigger;
+    sourceLabel?: CredentialAutoImportSourceLabel;
+}
+export declare function runExternalCredentialAutoImport({ authStorage, discover, discoveryOptions }: CredentialAutoImportOptions): Promise<CredentialAutoImportResult>;
+export declare function buildCredentialAutoImportNotice(result: Pick<CredentialAutoImportResult, "imported">): string | undefined;
+export declare function formatCredentialAutoImportResult(result: CredentialAutoImportResult): string[];
+export interface CredentialImportMarkerStore {
+    read: () => Promise<string | undefined> | string | undefined;
+    write: (version: string) => Promise<boolean> | boolean;
+}
+export interface StartupCredentialAutoImportOptions {
+    authStorage: CredentialAutoImportOptions["authStorage"];
+    modelRegistry: Pick<ModelRegistry, "refresh">;
+    discover?: CredentialAutoImportOptions["discover"];
+    version?: string;
+    agentDir?: string;
+    markerStore?: CredentialImportMarkerStore;
+}
+export declare function runStartupCredentialAutoImportIfNeeded({ authStorage: activeAuthStorage, modelRegistry: activeModelRegistry, discover, version, agentDir, markerStore }: StartupCredentialAutoImportOptions): Promise<string | undefined>;

package/dist/types/setup/credential-import.d.ts

@@ -3,6 +3,7 @@ import type { AuthCredential } from "@gajae-code/ai";
 export type ExternalProvider = "anthropic" | "openai-codex";
 /** Where a discovered credential came from. */
 export type CredentialOrigin = "claude-code-file" | "claude-code-keychain" | "codex-file";
+export declare const AUTO_IMPORT_OAUTH_PROVIDER_ORIGINS: Record<ExternalProvider, ReadonlySet<CredentialOrigin>>;
 /** Human labels for providers, used in redacted summaries. */
 export declare const EXTERNAL_PROVIDER_LABELS: Record<ExternalProvider, string>;
 /** A credential that can be safely imported into gjc's store. */
@@ -72,6 +73,8 @@ export declare function discoverExternalCredentials(options?: DiscoveryOptions):
 export declare function formatCredentialSummary(credential: ImportableCredential): string;
 /** Redacted summary lines for an entire discovery result. Never includes secrets. */
 export declare function formatDiscoverySummary(result: CredentialDiscoveryResult): string[];
+export declare function isAutoImportOAuthCredential(credential: ImportableCredential): boolean;
+export declare function filterAutoImportOAuthCredentials(credentials: readonly ImportableCredential[]): ImportableCredential[];
 /**
  * Persist discovered credentials via `upsert`. Each credential is imported
  * independently; a failure on one is recorded without aborting the rest.

package/dist/types/setup/host-plugin-setup.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Host plugin setup for `gjc setup claude` and `gjc setup codex`.
+ *
+ * Renders install guidance and a fail-closed coordinator MCP config preview for
+ * the canonical generated plugin bundle under `plugins/`. This is intentionally
+ * render-only and fail-closed: the workdir allowlist is scoped to the project
+ * root and no mutation class is enabled until the user opts in.
+ */
+export type HostPluginKind = "claude" | "codex";
+export interface HostPluginSetupFlags {
+    json?: boolean;
+    check?: boolean;
+    root?: string[];
+    repo?: string;
+}
+export interface HostPluginSetupResult {
+    ok: true;
+    host: HostPluginKind;
+    mode: "render";
+    gated: boolean;
+    pluginPath: string;
+    manifestPath: string;
+    marketplacePath: string;
+    installGuidance: string[];
+    coordinatorConfigPreview: {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+    };
+    mutationPolicy: string;
+    notes: string[];
+    check?: {
+        ok: boolean;
+        checked: string[];
+        missing: string[];
+    };
+}
+export declare function buildHostPluginSetup(host: HostPluginKind, flags?: HostPluginSetupFlags): HostPluginSetupResult;
+export declare function formatHostPluginSetup(result: HostPluginSetupResult): string;

package/dist/types/skill-state/active-state.d.ts

@@ -1,7 +1,7 @@
+import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill } from "./canonical-skills";
 import type { WorkflowStateReceipt } from "./workflow-state-contract";
 export declare const SKILL_ACTIVE_STATE_FILE = "skill-active-state.json";
-export declare const CANONICAL_GJC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
-export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];
+export { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill };
 export type WorkflowHudSeverity = "info" | "warning" | "blocked" | "error" | "success";
 export interface WorkflowHudChip {
     label: string;
@@ -44,6 +44,7 @@ export interface SkillActiveEntry {
     handoff_to?: string;
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
+    source_state_revision?: number;
 }
 export interface SkillActiveState {
     version?: number;
@@ -65,7 +66,7 @@ export interface SkillActiveState {
 }
 export interface SkillActiveStatePaths {
     rootPath: string;
-    sessionPath?: string;
+    sessionPath: string;
 }
 export interface SyncSkillActiveStateOptions {
     cwd: string;
@@ -83,6 +84,7 @@ export interface SyncSkillActiveStateOptions {
     handoff_to?: string;
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
+    sourceRevision?: number;
 }
 export declare function normalizeWorkflowHudSummary(raw: unknown): WorkflowHudSummary | undefined;
 export declare function isCanonicalGjcWorkflowSkill(skill: string): skill is CanonicalGjcWorkflowSkill;
@@ -102,13 +104,6 @@ export interface ApplyHandoffOptions {
     strict?: boolean;
 }
 /**
- * Atomically apply a workflow-skill handoff to both the session-scoped and
- * root `skill-active-state.json` files in a single write per file.
- *
- * Write order: **session first, root last**. The session file is the
- * source of truth for HUD; the root aggregate must never lead the session
- * during a handoff window. Each file is rewritten once with caller demoted
- * to `active:false` (preserving `handoff_to`/`handoff_at` lineage) and
- * callee promoted to `active:true` (with `handoff_from`/`handoff_at`).
+ * Atomically apply a workflow-skill handoff to the session-scoped active state.
  */
 export declare function applyHandoffToActiveState(options: ApplyHandoffOptions): Promise<void>;

package/dist/types/skill-state/canonical-skills.d.ts

@@ -0,0 +1,3 @@
+/** Native-free canonical GJC workflow skill identifiers. */
+export declare const CANONICAL_GJC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
+export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];

package/dist/types/skill-state/workflow-hud.d.ts

@@ -39,6 +39,8 @@ interface UltragoalHudState extends WorkflowGateHudState {
         event?: string;
         goalId?: string;
         timestamp?: string;
+        kind?: string;
+        evidence?: string;
     };
     updatedAt?: string;
 }

package/dist/types/task/spawn-gate.d.ts

@@ -1,6 +1,6 @@
 /** The hard, locked batch threshold enforced by the runtime gate. */
 export declare const DEFAULT_SPAWN_THRESHOLD = 4;
-/** The justification a large batch or reviewer-spawned explorer must supply to pass the hard gate. */
+/** The justification a large batch must supply to pass the hard gate. */
 export interface SpawnPlanReceipt {
     whyParallel: string;
     whyNotLocal: string;
@@ -14,14 +14,6 @@ export interface SpawnGateRequest {
     /** The spawn-plan receipt, when provided. */
     plan?: SpawnPlanReceipt;
 }
-export interface ReviewerExploreGateRequest {
-    /** Agent type/name doing the spawning, when known. */
-    spawningAgentType?: string | null;
-    /** Target agent type/name requested by the task call. */
-    targetAgent: string;
-    /** The spawn-plan receipt, when provided. */
-    plan?: SpawnPlanReceipt;
-}
 export type SpawnGateOutcome = "allowed" | "rejected";
 export interface SpawnGateDecision {
     outcome: SpawnGateOutcome;
@@ -35,4 +27,3 @@ export interface SpawnGateDecision {
 export declare function findMissingPlanFields(plan: SpawnPlanReceipt | undefined): string[];
 export declare function decide(childCount: number, threshold: number, plan: SpawnPlanReceipt | undefined): SpawnGateDecision;
 export declare function evaluateSpawnGate(request: SpawnGateRequest): SpawnGateDecision;
-export declare function evaluateReviewerExploreGate(request: ReviewerExploreGateRequest): SpawnGateDecision;

package/dist/types/tools/ask-answer-registry.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Process-wide registry mapping a session id to its active {@link AskAnswerSource}.
+ *
+ * Decouples the `ask` tool (which reads the source via `AgentSession`) from the
+ * notifications extension (which registers one), without threading a new method
+ * through the extension/runner/controller wiring. A session has at most one
+ * source; registering returns a disposer.
+ */
+import type { AskAnswerSource } from "./index";
+/** Register `source` for `sessionId`. Returns a disposer that clears it. */
+export declare function registerAskAnswerSource(sessionId: string, source: AskAnswerSource): () => void;
+/** The answer source for `sessionId`, if one is registered. */
+export declare function getAskAnswerSource(sessionId: string): AskAnswerSource | undefined;

package/dist/types/tools/index.d.ts

@@ -68,6 +68,17 @@ export type ContextFileEntry = {
 };
 export type { DiscoverableMCPTool } from "../runtime-mcp/discoverable-tool-metadata";
 export type { DiscoverableTool, DiscoverableToolSearchIndex, DiscoverableToolSearchResult, DiscoverableToolSource, } from "../tool-discovery/tool-index";
+/**
+ * Source of remote answers for interactive asks (e.g. a Telegram reply routed
+ * through the notifications SDK). Lets a pending ask resolve without RPC mode.
+ */
+export interface AskAnswerSource {
+    /**
+     * Race a remote answer against the local UI for one question. Resolves with the
+     * chosen option label or free-text answer, or `undefined` to defer to local UI.
+     */
+    awaitAnswer(question: string, options: string[], signal?: AbortSignal): Promise<string | undefined>;
+}
 /** Session context for tool factories */
 export interface ToolSession {
     /** Current working directory */
@@ -167,6 +178,13 @@ export interface ToolSession {
     getGoalModeState?: () => GoalModeState | undefined;
     /** Unattended workflow-gate emitter (present only when unattended mode is negotiated). */
     getWorkflowGateEmitter?: () => WorkflowGateEmitter | undefined;
+    /**
+     * Optional remote answer source for interactive asks. When present, the ask
+     * tool races the local UI selection against a remote answer (e.g. a Telegram
+     * reply via the notifications SDK) so asks can be answered without RPC mode.
+     * No-op when undefined: the ask path behaves exactly as before.
+     */
+    getAskAnswerSource?: () => AskAnswerSource | undefined;
     /** Optional per-session restriction for goal tool operations. */
     goalToolAllowedOps?: readonly ("create" | "get" | "complete" | "resume" | "drop" | "pause")[];
     /** Goal runtime for the active agent session. */

package/dist/types/tools/subagent.d.ts

@@ -42,6 +42,9 @@ export interface SubagentSnapshot {
     outputRef?: string;
     truncated?: boolean;
     guidance?: string;
+    steerMessage?: string;
+    steerState?: "queued" | "resume_queued" | "resume_started";
+    steerPauseRequested?: boolean;
     /** Live streaming progress for the awaited subagent (await panel only; UI detail). */
     progress?: AgentProgress;
     /** True when a live in-session progress producer exists for this subagent. */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.6.4",
+	"version": "0.7.0",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -51,12 +51,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.6.4",
-		"@gajae-code/agent-core": "0.6.4",
-		"@gajae-code/ai": "0.6.4",
-		"@gajae-code/natives": "0.6.4",
-		"@gajae-code/tui": "0.6.4",
-		"@gajae-code/utils": "0.6.4",
+		"@gajae-code/stats": "0.7.0",
+		"@gajae-code/agent-core": "0.7.0",
+		"@gajae-code/ai": "0.7.0",
+		"@gajae-code/natives": "0.7.0",
+		"@gajae-code/tui": "0.7.0",
+		"@gajae-code/utils": "0.7.0",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/scripts/build-binary.ts

@@ -66,6 +66,9 @@ async function main(): Promise<void> {
 					"../stats/src/sync-worker.ts",
 					"./src/tools/browser/tab-worker-entry.ts",
 					"./src/eval/js/worker-entry.ts",
+					// Hidden notify daemon CLI (loaded via dynamic import from notify-cli); list it
+					// explicitly so Bun standalone keeps `gjc notify daemon-internal` usable.
+					"./src/notifications/telegram-daemon-cli.ts",
 					"--outfile",
 					"dist/gjc",
 				],

package/src/async/job-manager.ts

@@ -84,7 +84,11 @@ export interface SubagentLiveHandle {
 	/** Request a cooperative safe-boundary pause (never aborts the in-flight tool). */
 	requestPause(): void;
 	/** Inject a steering message into the live session. */
-	injectMessage(content: string, deliverAs: "steer" | "followUp" | "nextTurn"): Promise<void>;
+	injectMessage(
+		content: string,
+		deliverAs: "steer" | "followUp" | "nextTurn",
+		opts?: { fromAgentId?: string },
+	): Promise<void>;
 }
 
 /**

package/src/cli/daemon-cli.ts

@@ -0,0 +1,122 @@
+/**
+ * `gjc daemon` command handler.
+ *
+ * Generic over the static built-in daemon controller map: lists/inspects
+ * daemons and drives cooperative stop/reload. Telegram is the only kind today.
+ */
+
+import { Settings } from "../config/settings";
+import { selectDaemonControllers } from "../daemon/builtin";
+import type {
+	BuiltInDaemonController,
+	DaemonKind,
+	DaemonOperationOptions,
+	DaemonOperationResult,
+	DaemonStatus,
+} from "../daemon/control-types";
+
+export type DaemonCliAction = "list" | "status" | "stop" | "reload";
+
+export interface DaemonCommandArgs {
+	action: DaemonCliAction;
+	kinds: DaemonKind[];
+	all: boolean;
+	json: boolean;
+	force: boolean;
+	gracefulTimeoutMs?: number;
+	killTimeoutMs?: number;
+	spawnIfStopped?: boolean;
+}
+
+export interface DaemonCommandDeps {
+	settings?: Settings;
+	controllers?: BuiltInDaemonController[];
+}
+
+const KNOWN_ACTIONS: DaemonCliAction[] = ["list", "status", "stop", "reload"];
+const KNOWN_KINDS: DaemonKind[] = ["telegram"];
+
+export function parseDaemonArgs(argv: string[]): DaemonCommandArgs | undefined {
+	if (argv.length === 0 || argv[0] !== "daemon") return undefined;
+	const rest = argv.slice(1);
+	const action = (KNOWN_ACTIONS as string[]).includes(rest[0] ?? "") ? (rest[0] as DaemonCliAction) : "status";
+	const positional = (KNOWN_ACTIONS as string[]).includes(rest[0] ?? "") ? rest.slice(1) : rest;
+	const kinds: DaemonKind[] = [];
+	let all = false;
+	let json = false;
+	let force = false;
+	let gracefulTimeoutMs: number | undefined;
+	let killTimeoutMs: number | undefined;
+	let spawnIfStopped: boolean | undefined;
+	for (let i = 0; i < positional.length; i++) {
+		const arg = positional[i];
+		if (arg === "--all") all = true;
+		else if (arg === "--json") json = true;
+		else if (arg === "--force") force = true;
+		else if (arg === "--spawn-if-stopped") spawnIfStopped = true;
+		else if (arg === "--graceful-timeout-ms") gracefulTimeoutMs = Number.parseInt(positional[++i], 10);
+		else if (arg === "--kill-timeout-ms") killTimeoutMs = Number.parseInt(positional[++i], 10);
+		else if (!arg.startsWith("--") && (KNOWN_KINDS as string[]).includes(arg)) kinds.push(arg as DaemonKind);
+	}
+	return { action, kinds, all, json, force, gracefulTimeoutMs, killTimeoutMs, spawnIfStopped };
+}
+
+function formatStatus(status: DaemonStatus): string {
+	const parts = [
+		`${status.kind}: ${status.health}`,
+		status.configured ? undefined : "(not configured)",
+		status.pid !== undefined ? `pid=${status.pid}` : undefined,
+		status.ownerId ? `owner=${status.ownerId}` : undefined,
+		status.rootCount !== undefined ? `roots=${status.rootCount}` : undefined,
+		`mode=${status.runtime.mode}`,
+	].filter(Boolean);
+	let line = parts.join(" ");
+	if (status.runtime.warning) line += `\n  warning: ${status.runtime.warning}`;
+	return line;
+}
+
+function formatResult(result: DaemonOperationResult): string {
+	const head = `${result.kind} ${result.action}: ${result.ok ? "ok" : "failed"} — ${result.message}`;
+	const warnings = result.warnings.map(w => `\n  warning: ${w}`).join("");
+	return head + warnings;
+}
+
+export async function runDaemonCommand(cmd: DaemonCommandArgs, deps: DaemonCommandDeps = {}): Promise<void> {
+	const unknownKinds = cmd.kinds.filter(kind => !(KNOWN_KINDS as string[]).includes(kind));
+	if (unknownKinds.length > 0) {
+		process.stderr.write(
+			`Unknown daemon kind(s): ${unknownKinds.join(", ")}. Known kinds: ${KNOWN_KINDS.join(", ")}.\n`,
+		);
+		process.exitCode = 1;
+		return;
+	}
+	const settings = deps.settings ?? (await Settings.init());
+	const controllers = deps.controllers ?? selectDaemonControllers(settings, cmd.kinds, cmd.all);
+
+	if (cmd.action === "list" || cmd.action === "status") {
+		const statuses = await Promise.all(controllers.map(c => c.status()));
+		if (cmd.json) {
+			process.stdout.write(`${JSON.stringify(statuses, null, 2)}\n`);
+		} else {
+			process.stdout.write(`${statuses.map(formatStatus).join("\n")}\n`);
+		}
+		return;
+	}
+
+	const opts: DaemonOperationOptions = {
+		gracefulTimeoutMs: cmd.gracefulTimeoutMs,
+		killTimeoutMs: cmd.killTimeoutMs,
+		force: cmd.force,
+		spawnIfStopped: cmd.spawnIfStopped,
+	};
+	const results: DaemonOperationResult[] = [];
+	for (const controller of controllers) {
+		results.push(cmd.action === "reload" ? await controller.reload(opts) : await controller.stop(opts));
+	}
+	if (cmd.json) {
+		process.stdout.write(`${JSON.stringify(results, null, 2)}\n`);
+	} else {
+		process.stdout.write(`${results.map(formatResult).join("\n")}\n`);
+	}
+	if (results.some(r => !r.ok)) process.exitCode = 1;
+}

package/src/cli/migrate-cli.ts

@@ -0,0 +1,106 @@
+/**
+ * `gjc migrate` — import MCP servers and skills from other coding agents.
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+import { getAgentDir, getMCPConfigPath, getProjectAgentDir, getProjectDir } from "@gajae-code/utils";
+import { planMigration } from "../migrate/action-planner";
+import { getAdapter } from "../migrate/adapters/index";
+import { executeActions } from "../migrate/executor";
+import { buildReport, renderHuman } from "../migrate/report";
+import {
+	type AdapterResult,
+	CANONICAL_SOURCE_ORDER,
+	MIGRATE_SOURCES,
+	type MigrateDestinations,
+	type MigrateReport,
+	type MigrateSource,
+} from "../migrate/types";
+
+export interface MigrateCommandArgs {
+	from: string[];
+	project: boolean;
+	force: boolean;
+	dryRun: boolean;
+	json: boolean;
+	/** Test seam: override home dir for source discovery. */
+	homeDir?: string;
+	/** Test seam: override cwd for project-scope destinations. */
+	cwd?: string;
+}
+
+export class MigrateArgsError extends Error {}
+
+/** Expand `all`/repeated `--from`, validate, and return sources in canonical order. */
+export function resolveSources(from: string[]): MigrateSource[] {
+	if (from.length === 0) {
+		throw new MigrateArgsError("No source selected. Use --from <claude-code|codex|opencode|all> (repeatable).");
+	}
+	const selected = new Set<MigrateSource>();
+	for (const raw of from) {
+		const value = raw.trim().toLowerCase();
+		if (value === "all") {
+			for (const s of MIGRATE_SOURCES) selected.add(s);
+			continue;
+		}
+		if (!(MIGRATE_SOURCES as readonly string[]).includes(value)) {
+			throw new MigrateArgsError(`Unknown source "${raw}". Valid: ${MIGRATE_SOURCES.join(", ")}, all.`);
+		}
+		selected.add(value as MigrateSource);
+	}
+	return CANONICAL_SOURCE_ORDER.filter(s => selected.has(s));
+}
+
+function resolveDestinations(project: boolean, cwd: string): MigrateDestinations {
+	const scope = project ? "project" : "user";
+	const skillsDir = project ? path.join(getProjectAgentDir(cwd), "skills") : path.join(getAgentDir(), "skills");
+	return { mcpConfigPath: getMCPConfigPath(scope, cwd), skillsDir };
+}
+
+/** Run the migration and return the report (does not set process.exitCode). */
+export async function runMigrate(args: MigrateCommandArgs): Promise<MigrateReport> {
+	const sources = resolveSources(args.from);
+	const cwd = args.cwd ?? getProjectDir();
+	const homeDir = args.homeDir ?? os.homedir();
+	const destinations = resolveDestinations(args.project, cwd);
+
+	const results: AdapterResult[] = [];
+	for (const source of sources) {
+		results.push(await getAdapter(source).collect({ homeDir }));
+	}
+
+	const { actions, warnings } = await planMigration({ results, destinations, force: args.force });
+	const finalActions = args.dryRun ? actions : await executeActions(actions);
+
+	return buildReport({
+		actions: finalActions,
+		warnings,
+		sources,
+		destinations,
+		dryRun: args.dryRun,
+		project: args.project,
+		force: args.force,
+	});
+}
+
+/** CLI entry: run, render, and set the process exit code. */
+export async function runMigrateCommand(args: MigrateCommandArgs): Promise<void> {
+	let report: MigrateReport;
+	try {
+		report = await runMigrate(args);
+	} catch (error) {
+		if (error instanceof MigrateArgsError) {
+			process.stderr.write(`${error.message}\n`);
+			process.exitCode = 2;
+			return;
+		}
+		throw error;
+	}
+
+	if (args.json) {
+		process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+	} else {
+		process.stdout.write(`${renderHuman(report)}\n`);
+	}
+	process.exitCode = report.ok ? 0 : 1;
+}