@sayknow-cli/coding-agent 0.5.2 → 0.5.6

package/src/session-import/types.ts

@@ -0,0 +1,163 @@
+/**
+ * Provider-neutral session-import contract (issue #3709).
+ *
+ * An import accepts ONE explicit user-selected Codex or Claude transcript/export
+ * file, normalizes it into the intermediate representation below, and rebuilds a
+ * bounded, redacted continuation context in one workspace-scoped native SKC
+ * session. A verified identical import is reused; otherwise a new session is
+ * published. The source file is only ever read; provider process state is never scraped.
+ */
+
+/** Providers with a first-party observable transcript/export format. */
+export type SessionImportProviderId = "codex" | "claude";
+
+/** Concrete on-disk format variants the adapters understand. */
+export type SessionImportFormatId = "codex-rollout-jsonl" | "claude-code-jsonl" | "claude-export-json";
+
+/** Maximum quarantined-record digests retained in memory during import. */
+export const SESSION_IMPORT_QUARANTINE_MAX_RECORDS = 512;
+
+/** One normalized conversational unit produced by a provider adapter. */
+export interface ImportedMessage {
+	/** Conversational role. Tool evidence is attached to assistant turns. */
+	role: "user" | "assistant";
+	/** Visible text (may be empty when only tool evidence exists). */
+	text: string;
+	/** ISO-8601 source timestamp when the record carried one. */
+	timestamp?: string;
+	/**
+	 * Bounded, already redacted tool/file evidence lines (e.g. `$ ls` → `ok`).
+	 * Rendered inline after the text so completed work stays visible.
+	 */
+	toolEvidence?: string[];
+}
+
+/** Provider-neutral normalized conversation. */
+export interface ImportedConversation {
+	provider: SessionImportProviderId;
+	format: SessionImportFormatId;
+	/** Source-side session/conversation identifier when the format carries one. */
+	sourceSessionId?: string;
+	/** Source title when the format carries one. */
+	title?: string;
+	/** Source workspace cwd when the format carries one. */
+	cwd?: string;
+	messages: ImportedMessage[];
+}
+
+/** Deterministic, actionable import failure codes. */
+export type SessionImportErrorCode =
+	| "invalid_request"
+	| "source_not_found"
+	| "source_unreadable"
+	| "source_changed"
+	| "unsupported_format"
+	| "format_mismatch"
+	| "malformed_input"
+	| "content_too_large"
+	| "destination_conflict"
+	| "io_failed";
+
+/** Import pipeline phase a failure belongs to. */
+export type SessionImportPhase =
+	| "request"
+	| "read"
+	| "detect"
+	| "parse"
+	| "normalize"
+	| "persist"
+	| "cleanup"
+	| "switch";
+
+export class SessionImportError extends Error {
+	readonly code: SessionImportErrorCode;
+	readonly phase: SessionImportPhase;
+	readonly retryable: boolean;
+	readonly limitBytes?: number;
+	readonly observedBytes?: number;
+
+	constructor(
+		code: SessionImportErrorCode,
+		phase: SessionImportPhase,
+		message: string,
+		options?: { retryable?: boolean; limitBytes?: number; observedBytes?: number },
+	) {
+		super(message);
+		this.name = "SessionImportError";
+		this.code = code;
+		this.phase = phase;
+		this.retryable = options?.retryable ?? false;
+		this.limitBytes = options?.limitBytes;
+		this.observedBytes = options?.observedBytes;
+	}
+}
+
+/** One record the adapter could not map. Never carries raw content. */
+export interface ImportQuarantineRecord {
+	/** 1-based record/line number in the source. */
+	record: number;
+	byteLength: number;
+	sha256: string;
+	reason: "invalid_json" | "unknown_record" | "missing_fields" | "oversized_record";
+}
+
+/** Bounded tallies reported to the user and persisted in provenance. */
+export interface SessionImportCounts {
+	/** Records successfully mapped into the normalized conversation. */
+	mapped: number;
+	/** Records quarantined (never silently dropped). */
+	quarantined: number;
+	/** Secret/credential redactions applied to imported text. */
+	redacted: number;
+	/** Messages omitted from the rendered context by head/tail bounding. */
+	omitted: number;
+}
+
+/** Provenance persisted as a `custom` session entry on the import target. */
+export interface SessionImportProvenance {
+	schemaVersion: 1;
+	customType: "session-import";
+	provider: SessionImportProviderId;
+	format: SessionImportFormatId;
+	/** Basename of the explicit user-selected source file (never a full path). */
+	sourceFileName: string;
+	sourceSessionId?: string;
+	sourceTitle?: string;
+	/** SHA-256 over the exact source bytes that were imported. */
+	sourceSha256: string;
+	sourceBytes: number;
+	/** RFC 4122 UUID of the SKC session that received the import. */
+	targetSessionId: string;
+	importedAt: string;
+	converterVersion: number;
+	sanitizerVersion: number;
+	counts: SessionImportCounts;
+	/** True when head/tail bounding elided part of the conversation. */
+	truncated: boolean;
+	quarantine: { present: boolean; truncated: boolean };
+}
+
+/** Fully prepared import: parsed, normalized, redacted, bounded. No session state mutated yet. */
+export interface PreparedSessionImport {
+	conversation: ImportedConversation;
+	/** Rendered continuation context for the `custom_message` entry. */
+	contextText: string;
+	provenance: Omit<SessionImportProvenance, "targetSessionId" | "importedAt">;
+	counts: SessionImportCounts;
+	/** Distinct redaction pattern ids that fired (for the user-facing summary). */
+	redactionKinds: string[];
+	/** Bounded digest-only records for durable quarantine metadata. */
+	quarantineRecords: ImportQuarantineRecord[];
+	sourceSha256: string;
+	sourceBytes: number;
+}
+
+/** Result of a completed or idempotently reused imported session. */
+export interface SessionImportCompleted {
+	targetSessionId: string;
+	targetPath: string;
+	title: string;
+	prepared: PreparedSessionImport;
+	/** True when the same source/version import already existed in this workspace. */
+	reused: boolean;
+}

package/src/skc-runtime/launch-worktree.ts

@@ -19,6 +19,9 @@ export interface SkcLaunchWorktreePlan {
 	detached: boolean;
 	baseRef: string;
 	branchName: string | null;
+	sourceCheckoutRoot: string;
+	relativeCwd: string;
+	relativeDependencyRoot: string | null;
 }
 
 export interface SkcLaunchWorktreeResult extends SkcLaunchWorktreePlan {
@@ -207,11 +210,49 @@ export function parseLaunchWorktreeMode(args: string[]): ParsedLaunchWorktreeMod
 	return { mode, remainingArgs };
 }
 
+function repoRelativePath(checkoutRoot: string, targetPath: string): string {
+	const relative = path.relative(checkoutRoot, targetPath);
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+		throw new Error(`worktree_cwd_outside_checkout:${targetPath}`);
+	}
+	return relative;
+}
+
+function hasPackageLockMetadata(directory: string): boolean {
+	return (
+		fs.existsSync(path.join(directory, "bun.lock")) ||
+		fs.existsSync(path.join(directory, "bun.lockb")) ||
+		fs.existsSync(path.join(directory, "pnpm-lock.yaml")) ||
+		fs.existsSync(path.join(directory, "pnpm-workspace.yaml")) ||
+		fs.existsSync(path.join(directory, "package-lock.json")) ||
+		fs.existsSync(path.join(directory, "npm-shrinkwrap.json"))
+	);
+}
+
+function resolveSourceDependencyRoot(checkoutRoot: string, cwd: string): string | null {
+	let current = path.resolve(cwd);
+	let nearestPackageRoot: string | null = null;
+	while (true) {
+		if (!nearestPackageRoot && fs.existsSync(path.join(current, "package.json"))) nearestPackageRoot = current;
+		if (hasPackageLockMetadata(current)) return current;
+		if (current === checkoutRoot) return nearestPackageRoot;
+		const parent = path.dirname(current);
+		if (parent === current) return nearestPackageRoot;
+		current = parent;
+	}
+}
+
 export function planLaunchWorktree(
 	cwd: string,
 	mode: SkcLaunchWorktreeMode,
 ): SkcLaunchWorktreePlan | { enabled: false } {
 	if (!mode.enabled) return { enabled: false };
+	const sourceCheckoutRoot = fs.realpathSync.native(path.resolve(runGit(cwd, ["rev-parse", "--show-toplevel"])));
+	const sourceCwd = fs.realpathSync.native(path.resolve(cwd));
+	const relativeCwd = repoRelativePath(sourceCheckoutRoot, sourceCwd);
+	const sourceDependencyRoot = resolveSourceDependencyRoot(sourceCheckoutRoot, sourceCwd);
+	const relativeDependencyRoot =
+		sourceDependencyRoot === null ? null : repoRelativePath(sourceCheckoutRoot, sourceDependencyRoot);
 	const repoRoot = resolveCanonicalRepoRoot(cwd);
 	const baseRef = runGit(repoRoot, ["rev-parse", "HEAD"]);
 	const branchName = mode.detached ? null : mode.name;
@@ -219,7 +260,17 @@ export function planLaunchWorktree(
 	const bucket = `${path.basename(repoRoot)}.sayknow-cli-worktrees`;
 	const worktreeSlug = mode.detached ? resolveSourceBranchSlug(repoRoot, baseRef) : sanitizePathToken(mode.name);
 	const worktreePath = path.join(path.dirname(repoRoot), bucket, worktreeSlug);
-	return { enabled: true, repoRoot, worktreePath, detached: mode.detached, baseRef, branchName };
+	return {
+		enabled: true,
+		repoRoot,
+		worktreePath,
+		detached: mode.detached,
+		baseRef,
+		branchName,
+		sourceCheckoutRoot,
+		relativeCwd,
+		relativeDependencyRoot,
+	};
 }
 
 export function ensureLaunchWorktree(
@@ -290,8 +341,216 @@ export function ensureLaunchWorktree(
 	};
 }
 
-export function ensureReusableNodeModules(sourceRoot: string, worktreePath: string): "symlink" | "present" | "missing" {
+interface WorktreePackageManifest {
+	packageManager?: unknown;
+}
+
+type WorktreePackageManager = "bun" | "npm" | "pnpm";
+
+interface ResolvedWorktreePackageManager {
+	name: WorktreePackageManager;
+	version: string | null;
+}
+
+interface WorktreeDependencyProbes {
+	isExecutableAvailable?: (name: Exclude<WorktreePackageManager, "bun">) => boolean;
+	version?: (name: WorktreePackageManager) => string;
+	spawnInstall?: (command: readonly string[], cwd: string) => { exitCode: number; stderr: string };
+}
+
+function fileSystemErrorCode(error: unknown): string | undefined {
+	return error && typeof error === "object" && "code" in error && typeof error.code === "string"
+		? error.code
+		: undefined;
+}
+
+function readWorktreePackageManifest(worktreePath: string): WorktreePackageManifest | null {
+	try {
+		return JSON.parse(fs.readFileSync(path.join(worktreePath, "package.json"), "utf8")) as WorktreePackageManifest;
+	} catch (error) {
+		if (fileSystemErrorCode(error) === "ENOENT") return null;
+		throw error;
+	}
+}
+
+function hasWorktreePackageMetadata(worktreePath: string, manifest: WorktreePackageManifest | null): boolean {
+	return (
+		manifest !== null ||
+		fs.existsSync(path.join(worktreePath, "bun.lock")) ||
+		fs.existsSync(path.join(worktreePath, "bun.lockb")) ||
+		fs.existsSync(path.join(worktreePath, "pnpm-lock.yaml")) ||
+		fs.existsSync(path.join(worktreePath, "pnpm-workspace.yaml")) ||
+		fs.existsSync(path.join(worktreePath, "package-lock.json")) ||
+		fs.existsSync(path.join(worktreePath, "npm-shrinkwrap.json"))
+	);
+}
+
+function declaredPackageManager(
+	manifest: WorktreePackageManifest | null,
+): { name: string; version: string | null } | null {
+	if (typeof manifest?.packageManager !== "string") return null;
+	const separator = manifest.packageManager.indexOf("@");
+	const name = (separator < 0 ? manifest.packageManager : manifest.packageManager.slice(0, separator)).trim();
+	if (!name) return null;
+	const version = separator < 0 ? null : manifest.packageManager.slice(separator + 1).trim() || null;
+	return { name, version };
+}
+
+function worktreeLockfiles(worktreePath: string): Array<{ manager: WorktreePackageManager; file: string }> {
+	const candidates: Array<{ manager: WorktreePackageManager; file: string }> = [
+		{ manager: "bun", file: "bun.lock" },
+		{ manager: "bun", file: "bun.lockb" },
+		{ manager: "pnpm", file: "pnpm-lock.yaml" },
+		{ manager: "npm", file: "package-lock.json" },
+		{ manager: "npm", file: "npm-shrinkwrap.json" },
+	];
+	return candidates.filter(candidate => fs.existsSync(path.join(worktreePath, candidate.file)));
+}
+
+function isWorktreePackageManager(value: string): value is WorktreePackageManager {
+	return value === "bun" || value === "npm" || value === "pnpm";
+}
+
+function resolveWorktreePackageManager(
+	worktreePath: string,
+	manifest: WorktreePackageManifest | null,
+): ResolvedWorktreePackageManager {
+	const declared = declaredPackageManager(manifest);
+	const declaredManager = declared && isWorktreePackageManager(declared.name) ? declared.name : null;
+	if (declared && !declaredManager) {
+		throw new Error(`worktree_dependency_manager_unsupported:${declared.name}`);
+	}
+
+	const lockfiles = worktreeLockfiles(worktreePath);
+	if (lockfiles.length === 0) throw new Error("worktree_dependency_lockfile_missing");
+	if (lockfiles.length > 1) {
+		throw new Error(`worktree_dependency_lockfile_ambiguous:${lockfiles.map(lockfile => lockfile.file).join(",")}`);
+	}
+	const lockfileManager = lockfiles[0]!.manager;
+	if (declaredManager && declaredManager !== lockfileManager) {
+		throw new Error(`worktree_dependency_manager_mismatch:${declaredManager}:${lockfileManager}`);
+	}
+	return { name: declaredManager ?? lockfileManager, version: declared?.version ?? null };
+}
+
+function removeLegacySourceNodeModulesLink(sourceRoot: string, worktreePath: string): void {
+	const target = path.join(worktreePath, "node_modules");
+	let targetStat: fs.Stats;
+	try {
+		targetStat = fs.lstatSync(target);
+	} catch (error) {
+		if (fileSystemErrorCode(error) === "ENOENT") return;
+		throw error;
+	}
+	if (!targetStat.isSymbolicLink()) return;
+
+	const sourceModules = path.join(sourceRoot, "node_modules");
+	const linkTarget = path.resolve(path.dirname(target), fs.readlinkSync(target));
+	let linksToSource = linkTarget === path.resolve(sourceModules);
+	try {
+		linksToSource = linksToSource || fs.realpathSync(target) === fs.realpathSync(sourceModules);
+	} catch (error) {
+		if (fileSystemErrorCode(error) !== "ENOENT") throw error;
+	}
+	if (!linksToSource) throw new Error(`worktree_node_modules_not_local:${target}`);
+	fs.unlinkSync(target);
+}
+
+function installedPackageManagerVersion(
+	name: WorktreePackageManager,
+	cwd: string,
+	probes: WorktreeDependencyProbes,
+): string {
+	const testVersion = probes.version?.(name);
+	if (testVersion !== undefined) return testVersion;
+	if (name === "bun") return Bun.version;
+	const result = Bun.spawnSync([name, "--version"], { cwd, stdout: "pipe", stderr: "ignore", timeout: 10_000 });
+	if (result.exitCode !== 0) throw new Error(`worktree_dependency_manager_unavailable:${name}`);
+	return result.stdout?.toString().trim() ?? "";
+}
+
+function worktreeInstallCommand(
+	manager: ResolvedWorktreePackageManager,
+	cwd: string,
+	probes: WorktreeDependencyProbes,
+): string[] {
+	const args = manager.name === "npm" ? ["ci"] : ["install", "--frozen-lockfile"];
+	if (manager.name !== "bun" && !(probes.isExecutableAvailable?.(manager.name) ?? Bun.which(manager.name) !== null)) {
+		throw new Error(`worktree_dependency_manager_unavailable:${manager.name}`);
+	}
+	if (manager.version) {
+		const installedVersion = installedPackageManagerVersion(manager.name, cwd, probes);
+		if (installedVersion !== manager.version) {
+			throw new Error(
+				`worktree_dependency_manager_version_mismatch:${manager.name}:${manager.version}:${installedVersion || "unknown"}`,
+			);
+		}
+	}
+	return [manager.name, ...args];
+}
+
+function boundedInstallFailure(stderr: string, exitCode: number): string {
+	const detail = stderr.trim().replace(/\s+/g, " ");
+	if (!detail) return `exit_${exitCode}`;
+	return detail.length <= 2048 ? detail : `${detail.slice(0, 2045)}...`;
+}
+
+function installWorktreeDependencies(
+	sourceRoot: string,
+	worktreePath: string,
+	manifest: WorktreePackageManifest | null,
+	probes: WorktreeDependencyProbes,
+): void {
+	removeLegacySourceNodeModulesLink(sourceRoot, worktreePath);
+	const manager = resolveWorktreePackageManager(worktreePath, manifest);
+	const command = worktreeInstallCommand(manager, worktreePath, probes);
+	let result: { exitCode: number; stderr: string };
+	try {
+		if (probes.spawnInstall) {
+			result = probes.spawnInstall(command, worktreePath);
+		} else {
+			const spawned = Bun.spawnSync(command, {
+				cwd: worktreePath,
+				stdout: "ignore",
+				stderr: "pipe",
+				timeout: 120_000,
+				maxBuffer: 64 * 1024,
+			});
+			result = { exitCode: spawned.exitCode, stderr: spawned.stderr?.toString() ?? "" };
+		}
+	} catch (error) {
+		const detail = error instanceof Error && error.message ? error.message : "spawn_failed";
+		throw new Error(`worktree_dependency_install_failed:${manager.name}:${detail.slice(0, 2048)}`);
+	}
+	if (result.exitCode !== 0) {
+		throw new Error(
+			`worktree_dependency_install_failed:${manager.name}:${boundedInstallFailure(result.stderr, result.exitCode)}`,
+		);
+	}
+
+	try {
+		const installed = fs.lstatSync(path.join(worktreePath, "node_modules"));
+		if (!installed.isDirectory() || installed.isSymbolicLink()) {
+			throw new Error("worktree_dependency_install_not_local");
+		}
+	} catch (error) {
+		if (fileSystemErrorCode(error) !== "ENOENT") throw error;
+	}
+}
+
+/** Package worktrees own their complete lockfile-resolved dependency graph. */
+
+export function ensureReusableNodeModules(
+	sourceRoot: string,
+	worktreePath: string,
+	probes: WorktreeDependencyProbes = {},
+): "symlink" | "present" | "missing" {
 	const target = path.join(worktreePath, "node_modules");
+	const manifest = readWorktreePackageManifest(worktreePath);
+	if (hasWorktreePackageMetadata(worktreePath, manifest)) {
+		installWorktreeDependencies(sourceRoot, worktreePath, manifest, probes);
+		return "present";
+	}
 	if (fs.existsSync(target)) return "present";
 	const source = path.join(sourceRoot, "node_modules");
 	if (!fs.existsSync(source)) return "missing";
@@ -299,6 +558,20 @@ export function ensureReusableNodeModules(sourceRoot: string, worktreePath: stri
 	return "symlink";
 }
 
+export function launchWorktreeCwd(plan: SkcLaunchWorktreePlan): string {
+	return path.resolve(plan.worktreePath, plan.relativeCwd);
+}
+
+export function ensureLaunchWorktreeDependencies(plan: SkcLaunchWorktreePlan): "symlink" | "present" | "missing" {
+	if (plan.relativeDependencyRoot === null) {
+		return ensureReusableNodeModules(plan.repoRoot, plan.worktreePath);
+	}
+	return ensureReusableNodeModules(
+		path.resolve(plan.sourceCheckoutRoot, plan.relativeDependencyRoot),
+		path.resolve(plan.worktreePath, plan.relativeDependencyRoot),
+	);
+}
+
 /** Result of {@link prepareLaunchWorktree}: the effective working directory, remaining args, and resolved worktree plan. */
 export interface PreparedLaunchWorktree {
 	cwd: string;
@@ -311,6 +584,6 @@ export function prepareLaunchWorktree(cwd: string, args: string[]): PreparedLaun
 	const planned = planLaunchWorktree(cwd, parsed.mode);
 	const ensured = ensureLaunchWorktree(planned);
 	if (!ensured.enabled) return { cwd, args: parsed.remainingArgs, worktree: ensured };
-	ensureReusableNodeModules(ensured.repoRoot, ensured.worktreePath);
-	return { cwd: ensured.worktreePath, args: parsed.remainingArgs, worktree: ensured };
+	ensureLaunchWorktreeDependencies(ensured);
+	return { cwd: launchWorktreeCwd(ensured), args: parsed.remainingArgs, worktree: ensured };
 }

package/src/slash-commands/acp-builtins.ts

@@ -15,7 +15,7 @@ export type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./t
  * see commands it cannot drive.
  */
 export const ACP_BUILTIN_SLASH_COMMANDS: AvailableCommand[] = BUILTIN_SLASH_COMMANDS_INTERNAL.filter(
-	command => command.handle !== undefined,
+	command => command.handle !== undefined && command.acp !== false,
 ).map(command => {
 	// Honor mode-specific copy: ACP clients receive concise text-mode
 	// descriptions/hints when the spec sets `acpDescription` / `acpInputHint`,
@@ -43,6 +43,10 @@ export async function executeAcpBuiltinSlashCommand(
 	const parsed = parseSlashCommand(text);
 	if (!parsed) return false;
 	const command = lookupBuiltinSlashCommand(parsed.name);
+	if (command?.acp === false) {
+		await runtime.output(`/${parsed.name} is not available over ACP.`);
+		return { consumed: true };
+	}
 	if (!command?.handle) {
 		const diagnostic = formatUnknownBuiltinSlashCommandDiagnostic(parsed.name);
 		if (!diagnostic) return false;

package/src/slash-commands/builtin-registry.ts

@@ -41,6 +41,7 @@ import {
 	sendNotificationTest,
 } from "../sdk/bus/notification-service";
 import { computeCacheMissCostSummary, formatCacheMissSummaryLines } from "../session/cache-economics";
+import { formatSessionImportSummary, runSessionImportCommand } from "../session-import";
 import { formatModelOnboardingGuidance } from "../setup/model-onboarding-guidance";
 import {
 	addApiCompatibleProvider,
@@ -510,6 +511,93 @@ const shutdownHandlerTui = (_command: ParsedSlashCommand, runtime: TuiSlashComma
 	return commandConsumed();
 };
 
+type SessionImportRunner = typeof runSessionImportCommand;
+
+function isBusySessionImportActivation(error: unknown): boolean {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "busy";
+}
+
+export async function handleImportSessionCommand(
+	command: ParsedSlashCommand,
+	runtime: SlashCommandRuntime,
+	importer: SessionImportRunner = runSessionImportCommand,
+): Promise<SlashCommandResult> {
+	if (runtime.session.isStreaming)
+		return usage("Cannot import a session while a response is streaming; wait for it to finish.", runtime);
+	const outcome = await importer(command.args, runtime.cwd);
+	if (outcome.kind === "error") return usage(outcome.message, runtime);
+	const importTargetLabel = outcome.result.reused ? "reused imported session" : "newly published imported session";
+	if (runtime.session.isStreaming)
+		return usage(
+			`Import completed, but the ${importTargetLabel} was not activated because a response started streaming. Resume it later from the session picker.`,
+			runtime,
+		);
+	let switched: boolean;
+	try {
+		switched = await runtime.session.switchSession(outcome.result.targetPath, { requireIdle: true });
+	} catch (error) {
+		return usage(
+			isBusySessionImportActivation(error)
+				? `Import completed, but the ${importTargetLabel} was not activated because a response or turn started. Resume it later from the session picker.`
+				: `Import completed, but the ${importTargetLabel} could not be activated. Resume it later from the session picker.`,
+			runtime,
+		);
+	}
+	if (!switched)
+		return usage(
+			`${outcome.result.reused ? "Import found an existing imported session" : "Import created a new session"}, but switching to it was cancelled. Resume it later from the session picker.`,
+			runtime,
+		);
+	await runtime.notifyTitleChanged?.();
+	await runtime.output(formatSessionImportSummary(outcome.result));
+	return commandConsumed();
+}
+
+export async function handleImportSessionTuiCommand(
+	command: ParsedSlashCommand,
+	runtime: TuiSlashCommandRuntime,
+	importer: SessionImportRunner = runSessionImportCommand,
+): Promise<SlashCommandResult> {
+	runtime.ctx.editor.setText("");
+	if (runtime.ctx.session.isStreaming) {
+		runtime.ctx.showError("Cannot import a session while a response is streaming; wait for it to finish.");
+		return;
+	}
+	const outcome = await importer(command.args, runtime.ctx.sessionManager.getCwd());
+	if (outcome.kind === "error") {
+		runtime.ctx.showError(outcome.message);
+		return;
+	}
+	const importTargetLabel = outcome.result.reused ? "reused imported session" : "newly published imported session";
+	if (runtime.ctx.session.isStreaming) {
+		runtime.ctx.showError(
+			`Import completed, but the ${importTargetLabel} was not activated because a response started streaming. Resume it later from the session picker.`,
+		);
+		return;
+	}
+	let resumed: boolean;
+	try {
+		resumed = await runtime.ctx.handleResumeSession(outcome.result.targetPath, { requireIdle: true });
+	} catch (error) {
+		runtime.ctx.showError(
+			isBusySessionImportActivation(error)
+				? `Import completed, but the ${importTargetLabel} was not activated because a response or turn started. Resume it later from the session picker.`
+				: `Import completed, but the ${importTargetLabel} could not be activated. Resume it later from the session picker.`,
+		);
+		return;
+	}
+	if (!resumed) {
+		runtime.ctx.showError(
+			`${outcome.result.reused ? "Import found an existing imported session" : "Import created a new session"}, but switching to it was cancelled. Resume it later from the session picker.`,
+		);
+		return;
+	}
+	const { prepared } = outcome.result;
+	const providerLabel = prepared.conversation.provider === "codex" ? "Codex" : "Claude";
+	runtime.ctx.showStatus(
+		`${outcome.result.reused ? "Reused" : "Imported"} ${providerLabel} session "${outcome.result.title}" (${prepared.conversation.messages.length} messages reconstructed${prepared.counts.redacted > 0 ? `, ${prepared.counts.redacted} secret values redacted` : ""}).`,
+	);
+}
 const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "notify",
@@ -882,6 +970,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		name: "export",
 		priority: 50,
 		description: "Export this session to an HTML file",
+		acp: false,
 		inlineHint: "[path]",
 		allowArgs: true,
 		handle: async (command, runtime) => {
@@ -906,6 +995,16 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "import-session",
+		priority: 51,
+		description: "Import or reuse a Codex or Claude session transcript",
+		acp: false,
+		inlineHint: "<transcript-file> [--provider codex|claude]",
+		allowArgs: true,
+		handle: handleImportSessionCommand,
+		handleTui: handleImportSessionTuiCommand,
+	},
 	{
 		name: "copy",
 		priority: 55,
@@ -1654,7 +1753,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "move",
 		description: "Move session to a different working directory",
-		acpDescription: "Move the current session file",
+		acp: false,
 		inlineHint: "<path>",
 		allowArgs: true,
 		handle: async (command, runtime) => {

package/src/slash-commands/types.ts

@@ -84,6 +84,11 @@ export interface SlashCommandSpec extends BuiltinSlashCommand {
 	aliases?: string[];
 	/** When false, the dispatcher refuses to handle invocations that include arguments. */
 	allowArgs?: boolean;
+	/**
+	 * Whether ACP may advertise and execute this command. Commands that read
+	 * caller-selected local paths must set this to false.
+	 */
+	acp?: boolean;
 	/**
 	 * ACP-specific override for `description`. Used by `ACP_BUILTIN_SLASH_COMMANDS`
 	 * when building `available_commands_update` payloads so the client receives

package/src/tools/ask.ts

@@ -595,6 +595,11 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 	readonly description: string;
 	readonly parameters = askSchema;
 	readonly strict = true;
+	/**
+	 * These fields are rendered to the user and carry no executable or durable
+	 * meaning. IDs and workflow/deep-interview metadata remain fail-closed.
+	 */
+	readonly displaySafeEscapedArgFields = ["questions.question", "questions.options.label"] as const;
 	readonly loadMode = "discoverable";
 
 	constructor(private readonly session: ToolSession) {