@sayknow-cli/coding-agent 0.2.4 → 0.2.6

package/src/cli/migrate-cli.ts

@@ -0,0 +1,106 @@
+/**
+ * `skc 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 "@sayknow-cli/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;
+}

package/src/cli/setup-cli.ts

@@ -374,6 +374,7 @@ async function handleHooksSetup(flags: { json?: boolean; check?: boolean }): Pro
 async function handleDefaultsSetup(flags: { json?: boolean; check?: boolean; force?: boolean }): Promise<void> {
 	const result = await installDefaultSkcDefinitions({ check: flags.check, force: flags.force });
 	const hasCheckFailure = result.missing > 0 || result.different > 0;
+	const inspectGuidance = `Inspect bundled skills with: ${APP_NAME} skills list; read one with: ${APP_NAME} skills read ralplan`;
 
 	if (flags.json) {
 		console.log(JSON.stringify(result, null, 2));
@@ -388,18 +389,30 @@ async function handleDefaultsSetup(flags: { json?: boolean; check?: boolean; for
 			console.error(
 				chalk.dim(`Missing: ${result.missing}; different: ${result.different}; matching: ${result.matching}`),
 			);
+			console.error(chalk.dim(inspectGuidance));
+			console.error(
+				chalk.dim(
+					`Compare embedded defaults before overwriting local files with: ${APP_NAME} setup defaults --force`,
+				),
+			);
 			process.exit(1);
 		}
 		console.log(chalk.green(`${theme.status.success} Default SKC workflow skills are installed`));
 		console.log(chalk.dim(`Target: ${result.targetRoot}`));
+		console.log(chalk.dim(inspectGuidance));
 		return;
 	}
 
 	console.log(chalk.green(`${theme.status.success} Default SKC workflow skills installed`));
 	console.log(chalk.dim(`Target: ${result.targetRoot}`));
 	console.log(chalk.dim(`Written: ${result.written}; skipped: ${result.skipped}`));
+	console.log(chalk.dim(inspectGuidance));
 	if (result.skipped > 0 && !flags.force) {
-		console.log(chalk.dim("Use --force to overwrite existing default workflow skill files."));
+		console.log(
+			chalk.dim(
+				`Existing local default workflow skill files were preserved. Use ${APP_NAME} setup defaults --force to overwrite them intentionally.`,
+			),
+		);
 	}
 }
 

package/src/cli/update-cli.ts

@@ -25,6 +25,8 @@ export interface InstalledVersionVerification {
 	ok: boolean;
 	actual?: string;
 	path?: string;
+	smokeTestFailed?: boolean;
+	smokeTestOutput?: string;
 }
 
 /** Paths and verifier used while replacing a downloaded binary update. */
@@ -226,6 +228,36 @@ async function verifyInstalledVersion(expectedVersion: string): Promise<Installe
 	}
 }
 
+async function verifyInstalledRuntime(expectedVersion: string): Promise<InstalledVersionVerification> {
+	const versionResult = await verifyInstalledVersion(expectedVersion);
+	if (!versionResult.ok || !versionResult.path) {
+		return versionResult;
+	}
+	try {
+		const smokeResult = await $`${versionResult.path} --smoke-test`.quiet().nothrow();
+		if (smokeResult.exitCode === 0) {
+			return versionResult;
+		}
+		return {
+			...versionResult,
+			ok: false,
+			smokeTestFailed: true,
+			smokeTestOutput: smokeResult.text().trim(),
+		};
+	} catch (error) {
+		return {
+			...versionResult,
+			ok: false,
+			smokeTestFailed: true,
+			smokeTestOutput: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+function printRestartGuidance(): void {
+	console.log(chalk.dim(`Restart ${APP_NAME} to use the new version`));
+}
+
 function printVerifiedVersion(expectedVersion: string): void {
 	console.log(chalk.green(`\n${theme.status.success} Updated to ${expectedVersion}`));
 }
@@ -289,20 +321,38 @@ export function formatManualUpdateInstructionsForTest(platform: NodeJS.Platform
 	return formatManualUpdateInstructions(platform);
 }
 
+function normalizeVerificationOutput(output: string | undefined): string {
+	return output?.replace(/\s+/g, " ").trim() ?? "";
+}
+
 function formatVerificationFailure(result: InstalledVersionVerification, expectedVersion: string): string {
+	if (result.smokeTestFailed) {
+		const output = normalizeVerificationOutput(result.smokeTestOutput);
+		const outputSuffix = output ? `: ${output}` : "";
+		const pathSuffix = result.path ? ` at ${result.path}` : "";
+		return `${APP_NAME}${pathSuffix} reports ${result.actual ?? expectedVersion}, but --smoke-test failed${outputSuffix}. Close running ${APP_NAME} sessions and reinstall to repair a stale or partial update.`;
+	}
 	if (result.actual) {
 		return `${APP_NAME} at ${result.path} still reports ${result.actual} (expected ${expectedVersion})`;
 	}
 	return `could not verify updated version${result.path ? ` at ${result.path}` : ""}`;
 }
 
+export function formatVerificationFailureForTest(
+	result: InstalledVersionVerification,
+	expectedVersion: string,
+): string {
+	return formatVerificationFailure(result, expectedVersion);
+}
+
 /**
  * Print post-update verification result.
  */
 async function printVerification(expectedVersion: string): Promise<void> {
-	const result = await verifyInstalledVersion(expectedVersion);
+	const result = await verifyInstalledRuntime(expectedVersion);
 	if (result.ok) {
 		printVerifiedVersion(expectedVersion);
+		printRestartGuidance();
 		return;
 	}
 	console.log(chalk.yellow(`\nWarning: ${formatVerificationFailure(result, expectedVersion)}`));
@@ -385,10 +435,10 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
 		tempPath,
 		backupPath,
 		expectedVersion,
-		verifyInstalledVersion,
+		verifyInstalledVersion: verifyInstalledRuntime,
 	});
 	printVerifiedVersion(expectedVersion);
-	console.log(chalk.dim(`Restart ${APP_NAME} to use the new version`));
+	printRestartGuidance();
 }
 
 /**

package/src/cli.ts

@@ -43,6 +43,7 @@ const commands: CommandEntry[] = [
 		load: () => import("./commands/contribution-prep").then(m => m.default),
 	},
 	{ name: "deep-interview", load: () => import("./commands/deep-interview").then(m => m.default) },
+	{ name: "migrate", load: () => import("./commands/migrate").then(m => m.default) },
 	{ name: "rlm", load: () => import("./commands/rlm").then(m => m.default) },
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
 	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },

package/src/commands/deep-interview.ts

@@ -11,11 +11,11 @@ export default class DeepInterview extends Command {
 		threshold: Flags.string({ description: "Override ambiguity threshold for kickoff" }),
 		"threshold-source": Flags.string({ description: "Describe the threshold override source" }),
 		"session-id": Flags.string({
-			description: "Route state/spec handoff through a session-scoped .skc state directory",
+			description: "Route state/spec handoff through a session-scoped .skc/_session-{sessionid} directory",
 		}),
 		write: Flags.boolean({ description: "Persist a final deep-interview spec through the sanctioned SKC CLI/API" }),
 		stage: Flags.string({ description: 'Spec stage for --write (currently "final")' }),
-		slug: Flags.string({ description: "Safe slug for .skc/specs/deep-interview-<slug>.md" }),
+		slug: Flags.string({ description: "Safe slug for .skc/_session-{sessionid}/specs/deep-interview-<slug>.md" }),
 		spec: Flags.string({ description: "Final spec markdown or a path to the final spec markdown" }),
 		handoff: Flags.string({ description: 'After --write, hand off to a workflow target (currently "ralplan")' }),
 		deliberate: Flags.boolean({

package/src/commands/launch.ts

@@ -169,7 +169,7 @@ export default class Index extends Command {
 				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,
+				project: launch.cwd,
 			})
 		)
 			return;

package/src/commands/migrate.ts

@@ -0,0 +1,46 @@
+/**
+ * Import MCP servers and skills from other coding agents into SKC.
+ */
+import { Command, Flags } from "@sayknow-cli/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 = [
+		"skc migrate --from claude-code",
+		"skc migrate --from codex --from opencode",
+		"skc migrate --from all --dry-run --json",
+		"skc 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 (./.skc) instead of the user scope (~/.skc)",
+			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/state.ts

@@ -2,7 +2,8 @@ import { Command } from "@sayknow-cli/utils/cli";
 import { runNativeStateCommand } from "../skc-runtime/state-runtime";
 
 export default class State extends Command {
-	static description = "Read or update SKC workflow state receipts under .skc/state";
+	static description =
+		"Read or update current-session SKC workflow state receipts under .skc/_session-{sessionid}/state";
 	static strict = false;
 	static examples = [
 		'$ skc 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 SKC tmux team orchestration from inside an existing tmux/SKC --tmux session; --dry-run writes ephemeral .skc/state/team state only";
+		"Run native SKC tmux team orchestration from inside an existing tmux/SKC --tmux session; --dry-run writes ephemeral .skc/_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 .skc/state/team state without starting tmux panes; do not commit generated state",
+				"Create ephemeral .skc/_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 .skc/state/team state only; do not commit generated .skc state"] : []),
+			...(dryRun
+				? [
+						"dry-run: wrote ephemeral .skc/_session-{sessionid}/state/team state only; do not commit generated .skc state",
+					]
+				: []),
 		]);
 	}
 }

package/src/config/model-registry.ts

@@ -872,7 +872,13 @@ const customReferenceMap = buildCustomReferenceMap();
 
 function getCustomReferenceCandidateIds(modelId: string): string[] {
 	const candidates = new Set<string>();
-	const queue = [modelId];
+	const minimaxM = /^minimax-m(\d+(?:\.\d+)*)$/i.exec(modelId.trim());
+	const queue = minimaxM ? [`MiniMax-M${minimaxM[1]}`, modelId] : [modelId];
+	if (minimaxM) {
+		// MiniMax catalogs include lowercase wire ids plus display-cased aliases.
+		// Custom providers should keep the lowercase wire id while inheriting the
+		// canonical display casing when the alias exists.
+	}
 	for (let index = 0; index < queue.length; index += 1) {
 		const candidate = queue[index]?.trim();
 		if (!candidate || candidates.has(candidate)) continue;
@@ -1212,13 +1218,14 @@ export class ModelRegistry {
 			const existingIndex = indexByKey.get(key);
 			if (existingIndex !== undefined) {
 				const existingModel = merged[existingIndex];
+				const referenceModel = resolveCustomModelReference(customModel.id);
 				merged[existingIndex] = enrichModelThinking({
 					...existingModel,
 					id: customModel.id,
 					provider: customModel.provider,
 					api: customModel.api,
 					baseUrl: customModel.baseUrl,
-					name: customModel.name ?? existingModel.name,
+					name: customModel.name ?? referenceModel?.name ?? existingModel.name,
 					reasoning: customModel.reasoning ?? existingModel.reasoning,
 					thinking: customModel.thinking ?? existingModel.thinking,
 					input: customModel.input ?? existingModel.input,

package/src/config/model-resolver.ts

@@ -147,12 +147,23 @@ export function resolveProviderModelReference(
 	modelId: string,
 	availableModels: readonly Model<Api>[],
 ): Model<Api> | undefined {
-	const normalizedProvider = provider.trim().toLowerCase();
-	const normalizedModelId = modelId.trim().toLowerCase();
+	const trimmedProvider = provider.trim();
+	const trimmedModelId = modelId.trim();
+	const normalizedProvider = trimmedProvider.toLowerCase();
+	const normalizedModelId = trimmedModelId.toLowerCase();
 	if (!normalizedProvider || !normalizedModelId) {
 		return undefined;
 	}
 
+	// Prefer an exact provider/model id match before falling back to the
+	// case-insensitive index. Some provider catalogs intentionally carry both a
+	// machine-id form (for example `minimax-m3`) and a display-cased alias
+	// (`MiniMax-M3`). The lowercase index correctly treats those aliases as
+	// ambiguous for fuzzy/case-insensitive lookup, but an exact selector should
+	// still resolve deterministically.
+	const caseExact = availableModels.find(m => m.provider === trimmedProvider && m.id === trimmedModelId);
+	if (caseExact) return caseExact;
+
 	const index = getProviderModelIndex(availableModels);
 	const exact = index.get(`${normalizedProvider}\u0000${normalizedModelId}`);
 	if (exact === null) {

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

@@ -22,6 +22,7 @@ const ReasoningEffortMapSchema = z.object({
 export const OpenAICompatSchema = z.object({
 	supportsStore: z.boolean().optional(),
 	supportsDeveloperRole: z.boolean().optional(),
+	sendSessionHeaders: z.boolean().optional(),
 	supportsMultipleSystemMessages: z.boolean().optional(),
 	supportsReasoningEffort: z.boolean().optional(),
 	reasoningEffortMap: ReasoningEffortMapSchema.optional(),

package/src/config/settings-schema.ts

@@ -1087,6 +1087,23 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"startup.welcomeBannerMode": {
+		type: "enum",
+		values: ["auto", "unicode", "square", "ascii"] as const,
+		default: "auto",
+		ui: {
+			tab: "interaction",
+			label: "Welcome Banner Mode",
+			description: "Logo style for the startup welcome screen",
+			options: [
+				{ value: "auto", label: "Auto", description: "Use the rounded Unicode logo" },
+				{ value: "unicode", label: "Unicode", description: "Force the rounded Unicode logo" },
+				{ value: "square", label: "Square Unicode", description: "Force the square-corner Unicode fallback" },
+				{ value: "ascii", label: "ASCII", description: "Force the ASCII-safe logo" },
+			],
+		},
+	},
+
 	"startup.checkUpdate": {
 		type: "boolean",
 		default: true,

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, skcRoot } from "../skc-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, skcSessionId?: string): string {
+	return skcSessionId
+		? coordinatorMcpStateRoot(cwd, skcSessionId)
+		: path.join(skcRoot(cwd), "state", "coordinator-mcp");
+}
+
 export function buildCoordinatorMcpConfig(env: NodeJS.ProcessEnv = process.env): CoordinatorMcpConfig {
-	const stateRoot =
-		env.SKC_COORDINATOR_MCP_STATE_ROOT?.trim() || path.join(process.cwd(), ".skc", "state", "coordinator-mcp");
+	const stateRootOverride = env.SKC_COORDINATOR_MCP_STATE_ROOT?.trim();
+	const skcSessionId = env.SKC_SESSION_ID?.trim();
+	const stateRoot = stateRootOverride || defaultCoordinatorMcpStateRoot(process.cwd(), skcSessionId);
 	return {
 		allowedRoots: parseRootList(env.SKC_COORDINATOR_MCP_WORKDIR_ROOTS).map(root => path.resolve(root)),
 		mutationClasses: parseMutationClasses(

package/src/defaults/skc/extensions/grok-cli-vendor/biome.json

@@ -1,5 +1,4 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.4.16/schema.json",
   "root": false,
   "vcs": {
     "enabled": true,