@gajae-code/coding-agent 0.5.4 → 0.6.1

package/src/config/settings-schema.ts

@@ -1000,7 +1000,7 @@ export const SETTINGS_SCHEMA = {
 			tab: "interaction",
 			label: "Busy Prompt Mode",
 			description:
-				"What a submitted prompt does while the agent is busy: steer (interrupt the active turn) or queue (run after the active turn completes)",
+				"What a submitted prompt does while the agent is busy: queue normal chat for the next turn, or steer to interrupt the active turn",
 		},
 	},
 
@@ -2160,6 +2160,66 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"computer.enabled": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			label: "Computer",
+			description: "Enable the macOS computer tool for this session. Off by default.",
+		},
+	},
+
+	"computer.alwaysOn": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			label: "Computer Always On",
+			description: "Keep the macOS computer tool callable without per-session enablement.",
+		},
+	},
+
+	"computer.autoScreenshot": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			label: "Computer Auto Screenshot",
+			description: "Automatically request bounded screenshots after computer actions when supported.",
+		},
+	},
+
+	"computer.screenshotMaxBytes": {
+		type: "number",
+		default: 5_000_000,
+		ui: {
+			tab: "tools",
+			label: "Computer Screenshot Max Bytes",
+			description: "Maximum screenshot payload size for computer action results.",
+		},
+	},
+
+	"computer.killSwitchHotkey": {
+		type: "string",
+		default: "Control+Option+Command+Escape",
+		ui: {
+			tab: "tools",
+			label: "Computer Kill Switch Hotkey",
+			description: "Native stop/suspend hotkey shown to users for computer-use sessions.",
+		},
+	},
+
+	"computer.auditLog.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "tools",
+			label: "Computer Audit Log",
+			description: "Persist audit records for enabled computer-use actions.",
+		},
+	},
+
 	// Tool execution
 	"tools.intentTracing": {
 		type: "boolean",
@@ -2647,6 +2707,7 @@ export const SETTINGS_SCHEMA = {
 			"anthropic",
 			"gemini",
 			"codex",
+			"xai",
 			"tavily",
 			"kagi",
 			"synthetic",
@@ -2688,6 +2749,11 @@ export const SETTINGS_SCHEMA = {
 					label: "OpenAI",
 					description: "OpenAI's native web_search (uses ChatGPT OAuth via /login openai-codex)",
 				},
+				{
+					value: "xai",
+					label: "xAI",
+					description: "xAI Responses web_search/x_search (uses xAI OAuth via /login xai or XAI_API_KEY)",
+				},
 				{
 					value: "gemini",
 					label: "Gemini",

package/src/edit/notebook.ts

@@ -49,7 +49,7 @@ function cloneCell(cell: NotebookCell): NotebookCell {
 	return structuredClone(cell);
 }
 
-function createNotebookCell(cellType: NotebookCellType, source: string): NotebookCell {
+export function createNotebookCell(cellType: NotebookCellType, source: string): NotebookCell {
 	const cell: NotebookCell = {
 		cell_type: cellType,
 		metadata: {},
@@ -62,7 +62,7 @@ function createNotebookCell(cellType: NotebookCellType, source: string): Noteboo
 	return cell;
 }
 
-function createEmptyNotebook(): NotebookDocument {
+export function createEmptyNotebook(): NotebookDocument {
 	return {
 		cells: [],
 		metadata: {},
@@ -71,6 +71,10 @@ function createEmptyNotebook(): NotebookDocument {
 	};
 }
 
+export function serializeNotebookDocument(notebook: NotebookDocument): string {
+	return JSON.stringify(notebook, null, 1);
+}
+
 function validateNotebook(value: unknown, displayPath: string): NotebookDocument {
 	if (!isRecord(value)) {
 		throw new Error(`Invalid notebook structure (expected object): ${displayPath}`);

package/src/eval/py/executor.ts

@@ -12,6 +12,7 @@ import {
 	type KernelExecuteResult,
 	PythonKernel,
 } from "./kernel";
+import type { PythonRuntimeOptions } from "./runtime";
 import { ensurePyToolBridge, registerPyToolBridge } from "./tool-bridge";
 
 export type PythonKernelMode = "session" | "per-call";
@@ -44,6 +45,8 @@ export interface PythonExecutorOptions {
 	 * preferred over `PI_SESSION_FILE`-derived paths.
 	 */
 	artifactsDir?: string;
+	/** Runtime resolution/provisioning options (RLM managed workspace venv, package seeding). */
+	runtimeOptions?: PythonRuntimeOptions;
 	/** Artifact path/id for full output storage */
 	artifactPath?: string;
 	artifactId?: string;
@@ -276,6 +279,7 @@ async function startKernel(cwd: string, options: PythonExecutorOptions): Promise
 	return await PythonKernel.start({
 		cwd,
 		env: buildKernelEnv(options),
+		runtimeOptions: options.runtimeOptions,
 		signal: options.signal,
 		deadlineMs: options.deadlineMs,
 	});
@@ -562,7 +566,10 @@ async function executeWithKernel(
 }
 
 async function ensureKernelAvailable(cwd: string, options: PythonExecutorOptions): Promise<void> {
-	const availability = await waitForPromiseWithCancellation(checkPythonKernelAvailability(cwd), options);
+	const availability = await waitForPromiseWithCancellation(
+		checkPythonKernelAvailability(cwd, options.runtimeOptions),
+		options,
+	);
 	if (!availability.ok) {
 		throw new Error(availability.reason ?? "Python kernel unavailable");
 	}

package/src/eval/py/kernel.ts

@@ -18,7 +18,7 @@ import { Settings } from "../../config/settings";
 import { type KernelDisplayOutput, renderKernelDisplay } from "./display";
 import { PYTHON_PRELUDE } from "./prelude";
 import RUNNER_SCRIPT from "./runner.py" with { type: "text" };
-import { filterEnv, resolvePythonRuntime } from "./runtime";
+import { ensurePythonRuntime, filterEnv, type PythonRuntimeOptions } from "./runtime";
 
 export type { KernelDisplayOutput, PythonStatusEvent } from "./display";
 export { renderKernelDisplay } from "./display";
@@ -89,6 +89,7 @@ interface KernelLifecycleOptions {
 interface KernelStartOptions extends KernelLifecycleOptions {
 	cwd: string;
 	env?: Record<string, string | undefined>;
+	runtimeOptions?: PythonRuntimeOptions;
 }
 
 interface KernelShutdownOptions {
@@ -120,7 +121,10 @@ function throwIfAborted(signal: AbortSignal | undefined, fallbackReason: string)
 	throw createAbortError("AbortError", typeof reason === "string" ? reason : fallbackReason);
 }
 
-export async function checkPythonKernelAvailability(cwd: string): Promise<PythonKernelAvailability> {
+export async function checkPythonKernelAvailability(
+	cwd: string,
+	runtimeOptions?: PythonRuntimeOptions,
+): Promise<PythonKernelAvailability> {
 	if (isBunTestRuntime() || $flag("PI_PYTHON_SKIP_CHECK")) {
 		return { ok: true };
 	}
@@ -128,7 +132,7 @@ export async function checkPythonKernelAvailability(cwd: string): Promise<Python
 		const settings = await Settings.init();
 		const { env } = settings.getShellConfig();
 		const baseEnv = filterEnv(env);
-		const runtime = resolvePythonRuntime(cwd, baseEnv);
+		const runtime = await ensurePythonRuntime(cwd, baseEnv, runtimeOptions);
 		const probe = await $`${runtime.pythonPath} -c "import sys;sys.exit(0)"`
 			.quiet()
 			.nothrow()
@@ -199,6 +203,7 @@ export class PythonKernel {
 			"PythonKernel.start:availabilityCheck",
 			checkPythonKernelAvailability,
 			options.cwd,
+			options.runtimeOptions,
 		);
 		if (!availability.ok) {
 			throw new Error(availability.reason ?? "Python kernel unavailable");
@@ -207,7 +212,7 @@ export class PythonKernel {
 		const settings = await Settings.init();
 		const { env: shellEnv } = settings.getShellConfig();
 		const baseEnv = filterEnv(shellEnv);
-		const runtime = resolvePythonRuntime(options.cwd, baseEnv);
+		const runtime = await ensurePythonRuntime(options.cwd, baseEnv, options.runtimeOptions);
 		const spawnEnv: Record<string, string> = {};
 		for (const [key, value] of Object.entries(runtime.env)) {
 			if (typeof value === "string") spawnEnv[key] = value;

package/src/eval/py/runtime.ts

@@ -1,13 +1,23 @@
 /**
  * Python runtime resolution utilities.
  *
- * Centralizes environment filtering, venv detection, and Python executable resolution
- * for both the shared gateway and local kernel spawning.
+ * Centralizes environment filtering, venv detection, managed workspace venv
+ * provisioning, and Python executable resolution for both the shared gateway
+ * and local kernel spawning.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { $env, $which, getPythonEnvDir } from "@gajae-code/utils";
 
+export const RLM_MANAGED_PYTHON_PACKAGES: readonly string[] = ["numpy", "pandas", "matplotlib", "polars"];
+
+export interface PythonRuntimeOptions {
+	/** Create/use <cwd>/.gjc/python-env when no BYO venv/conda env is present. */
+	managedWorkspaceVenv?: boolean;
+	/** Packages to seed into the managed workspace venv when provisioning it. */
+	seedPackages?: readonly string[];
+}
+
 const DEFAULT_ENV_ALLOWLIST = new Set([
 	"PATH",
 	"HOME",
@@ -104,15 +114,22 @@ function resolvePathKey(env: Record<string, string | undefined>): string {
 	return match ?? "PATH";
 }
 
-function resolveManagedPythonEnv(): string {
+function resolveGlobalManagedPythonEnv(): string {
 	return getPythonEnvDir();
 }
 
-function resolveManagedPythonCandidate(): { venvPath: string; pythonPath: string } {
-	const venvPath = resolveManagedPythonEnv();
+function resolvePythonCandidateInVenv(venvPath: string): { venvPath: string; pythonPath: string; binDir: string } {
 	const binDir = process.platform === "win32" ? path.join(venvPath, "Scripts") : path.join(venvPath, "bin");
 	const pythonPath = path.join(binDir, process.platform === "win32" ? "python.exe" : "python");
-	return { venvPath, pythonPath };
+	return { venvPath, pythonPath, binDir };
+}
+
+function resolveManagedPythonCandidate(): { venvPath: string; pythonPath: string; binDir: string } {
+	return resolvePythonCandidateInVenv(resolveGlobalManagedPythonEnv());
+}
+
+function resolveWorkspaceManagedPythonCandidate(cwd: string): { venvPath: string; pythonPath: string; binDir: string } {
+	return resolvePythonCandidateInVenv(path.join(cwd, ".gjc", "python-env"));
 }
 
 export interface PythonRuntime {
@@ -124,6 +141,23 @@ export interface PythonRuntime {
 	venvPath?: string;
 }
 
+function runtimeFromVenv(
+	venvPath: string,
+	pythonPath: string,
+	binDir: string,
+	env: Record<string, string | undefined>,
+): PythonRuntime {
+	env.VIRTUAL_ENV = venvPath;
+	const pathKey = resolvePathKey(env);
+	const currentPath = env[pathKey];
+	env[pathKey] = currentPath ? `${binDir}${path.delimiter}${currentPath}` : binDir;
+	return {
+		pythonPath,
+		env,
+		venvPath,
+	};
+}
+
 /**
  * Filter environment variables to a safe allowlist for Python subprocesses.
  * Removes sensitive API keys and limits to known-safe variables.
@@ -161,42 +195,110 @@ export function resolveVenvPath(cwd: string): string | undefined {
 	return undefined;
 }
 
+async function runRuntimeCommand(
+	cmd: string[],
+	cwd: string,
+	env: Record<string, string | undefined>,
+	description: string,
+): Promise<void> {
+	const spawnEnv: Record<string, string> = {};
+	for (const [key, value] of Object.entries(env)) {
+		if (typeof value === "string") spawnEnv[key] = value;
+	}
+	const proc = Bun.spawn(cmd, {
+		cwd,
+		env: spawnEnv,
+		stdout: "pipe",
+		stderr: "pipe",
+		windowsHide: true,
+	});
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	if (exitCode !== 0) {
+		const output = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
+		throw new Error(`${description} failed with exit code ${exitCode}${output ? `: ${output}` : ""}`);
+	}
+}
+
+async function ensureWorkspaceManagedVenv(
+	cwd: string,
+	baseEnv: Record<string, string | undefined>,
+	seedPackages: readonly string[],
+): Promise<void> {
+	const managed = resolveWorkspaceManagedPythonCandidate(cwd);
+	if (!fs.existsSync(managed.pythonPath)) {
+		const basePython = $which("python3") ?? $which("python");
+		if (!basePython) throw new Error("Python executable not found on PATH");
+		await fs.promises.mkdir(path.dirname(managed.venvPath), { recursive: true });
+		await runRuntimeCommand(
+			[basePython, "-m", "venv", managed.venvPath],
+			cwd,
+			baseEnv,
+			"Managed Python venv creation",
+		);
+	}
+	if (seedPackages.length === 0) return;
+	const markerPath = path.join(managed.venvPath, ".gjc-seeded.json");
+	let seeded = false;
+	try {
+		const marker = JSON.parse(await fs.promises.readFile(markerPath, "utf8")) as { packages?: unknown };
+		const packages = Array.isArray(marker.packages) ? marker.packages : [];
+		seeded = seedPackages.every(pkg => packages.includes(pkg));
+	} catch {
+		seeded = false;
+	}
+	if (seeded) return;
+	const runtimeEnv = runtimeFromVenv(managed.venvPath, managed.pythonPath, managed.binDir, { ...baseEnv }).env;
+	await runRuntimeCommand(
+		[managed.pythonPath, "-m", "pip", "install", "--upgrade", "pip"],
+		cwd,
+		runtimeEnv,
+		"Managed Python pip bootstrap",
+	);
+	await runRuntimeCommand(
+		[managed.pythonPath, "-m", "pip", "install", ...seedPackages],
+		cwd,
+		runtimeEnv,
+		"Managed Python package seed",
+	);
+	await fs.promises.writeFile(
+		markerPath,
+		`${JSON.stringify({ packages: seedPackages, seededAt: new Date().toISOString() }, null, 2)}\n`,
+		"utf8",
+	);
+}
+
 /**
  * Resolve Python runtime including executable path, environment, and venv detection.
  */
-export function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string | undefined>): PythonRuntime {
+export function resolvePythonRuntime(
+	cwd: string,
+	baseEnv: Record<string, string | undefined>,
+	options: PythonRuntimeOptions = {},
+): PythonRuntime {
 	const env = { ...baseEnv };
 	const venvPath = env.VIRTUAL_ENV ?? resolveVenvPath(cwd);
 
 	if (venvPath) {
-		env.VIRTUAL_ENV = venvPath;
-		const binDir = process.platform === "win32" ? path.join(venvPath, "Scripts") : path.join(venvPath, "bin");
-		const pythonCandidate = path.join(binDir, process.platform === "win32" ? "python.exe" : "python");
-		if (fs.existsSync(pythonCandidate)) {
-			const pathKey = resolvePathKey(env);
-			const currentPath = env[pathKey];
-			env[pathKey] = currentPath ? `${binDir}${path.delimiter}${currentPath}` : binDir;
-			return {
-				pythonPath: pythonCandidate,
-				env,
-				venvPath,
-			};
+		const candidate = resolvePythonCandidateInVenv(venvPath);
+		if (fs.existsSync(candidate.pythonPath)) {
+			return runtimeFromVenv(candidate.venvPath, candidate.pythonPath, candidate.binDir, env);
 		}
 	}
 
-	const managed = resolveManagedPythonCandidate();
-	if (fs.existsSync(managed.pythonPath)) {
-		env.VIRTUAL_ENV = managed.venvPath;
-		const pathKey = resolvePathKey(env);
-		const currentPath = env[pathKey];
-		const managedBin =
-			process.platform === "win32" ? path.join(managed.venvPath, "Scripts") : path.join(managed.venvPath, "bin");
-		env[pathKey] = currentPath ? `${managedBin}${path.delimiter}${currentPath}` : managedBin;
-		return {
-			pythonPath: managed.pythonPath,
-			env,
-			venvPath: managed.venvPath,
-		};
+	if (options.managedWorkspaceVenv) {
+		const workspaceManaged = resolveWorkspaceManagedPythonCandidate(cwd);
+		if (fs.existsSync(workspaceManaged.pythonPath)) {
+			return runtimeFromVenv(workspaceManaged.venvPath, workspaceManaged.pythonPath, workspaceManaged.binDir, env);
+		}
+	} else {
+		const managed = resolveManagedPythonCandidate();
+		if (fs.existsSync(managed.pythonPath)) {
+			return runtimeFromVenv(managed.venvPath, managed.pythonPath, managed.binDir, env);
+		}
 	}
 
 	const pythonPath = $which("python") ?? $which("python3");
@@ -208,3 +310,22 @@ export function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string
 		env,
 	};
 }
+
+export async function ensurePythonRuntime(
+	cwd: string,
+	baseEnv: Record<string, string | undefined>,
+	options: PythonRuntimeOptions = {},
+): Promise<PythonRuntime> {
+	if (options.managedWorkspaceVenv) {
+		const env = { ...baseEnv };
+		const venvPath = env.VIRTUAL_ENV ?? resolveVenvPath(cwd);
+		if (venvPath) {
+			const candidate = resolvePythonCandidateInVenv(venvPath);
+			if (fs.existsSync(candidate.pythonPath)) {
+				return runtimeFromVenv(candidate.venvPath, candidate.pythonPath, candidate.binDir, env);
+			}
+		}
+		await ensureWorkspaceManagedVenv(cwd, baseEnv, options.seedPackages ?? RLM_MANAGED_PYTHON_PACKAGES);
+	}
+	return resolvePythonRuntime(cwd, baseEnv, options);
+}

package/src/exec/bash-executor.ts

@@ -34,6 +34,10 @@ export interface BashExecutorOptions {
 	artifactId?: string;
 	/** Execute without retaining a native Shell in the persistent session registry. */
 	oneShot?: boolean;
+	/** Ignore user-configured shell command prefixes. Used by constrained read-only shells. */
+	ignoreShellPrefix?: boolean;
+	/** Skip sourced shell snapshots. Used by constrained read-only shells. */
+	disableShellSnapshot?: boolean;
 	/**
 	 * Invoked when the native minimizer rewrote the command's output, giving
 	 * the caller a chance to persist the lossless original capture (typically
@@ -119,15 +123,17 @@ export function buildMinimizerOptions(group: ShellMinimizerSettings): MinimizerO
 export async function executeBash(command: string, options?: BashExecutorOptions): Promise<BashResult> {
 	const settings = await Settings.init();
 	const { shell, env: shellEnv, prefix } = settings.getShellConfig();
-	const snapshotPath = shell.includes("bash") ? await getOrCreateSnapshot(shell, shellEnv) : null;
+	const configuredPrefix = options?.ignoreShellPrefix ? undefined : prefix;
+	const snapshotPath =
+		!options?.disableShellSnapshot && shell.includes("bash") ? await getOrCreateSnapshot(shell, shellEnv) : null;
 
 	const minimizer = buildMinimizerOptions(settings.getGroup("shellMinimizer"));
 
 	const commandCwd = await resolveShellCwd(options?.cwd);
 	const commandEnv = options?.env ? { ...NON_INTERACTIVE_ENV, ...options.env } : NON_INTERACTIVE_ENV;
 
-	// Apply command prefix if configured
-	const prefixedCommand = prefix ? `${prefix} ${command}` : command;
+	// Apply command prefix if configured and allowed for this execution.
+	const prefixedCommand = configuredPrefix ? `${configuredPrefix} ${command}` : command;
 	const finalCommand = prefixedCommand;
 
 	// Create output sink for truncation and artifact handling
@@ -160,7 +166,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	}
 
 	const usePersistentShell = options?.oneShot !== true;
-	const sessionKey = buildSessionKey(shell, prefix, snapshotPath, shellEnv, options?.sessionKey, minimizer);
+	const sessionKey = buildSessionKey(shell, configuredPrefix, snapshotPath, shellEnv, options?.sessionKey, minimizer);
 	const persistentSessionBroken = usePersistentShell && brokenShellSessions.has(sessionKey);
 
 	let shellSession = persistentSessionBroken || !usePersistentShell ? undefined : shellSessions.get(sessionKey);

package/src/extensibility/custom-tools/types.ts

@@ -180,6 +180,8 @@ export interface CustomTool<TParams extends TSchema = TSchema, TDetails = any> {
 	label: string;
 	/** If true, tool is strictly typed and validated against the parameters schema before execution */
 	strict?: boolean;
+	/** Tool scheduling mode; exclusive tools do not run in parallel with other tools in a model turn. */
+	concurrency?: "shared" | "exclusive";
 	/** Description for LLM */
 	description: string;
 	/** Parameter schema (Zod or TypeBox; TypeBox is auto-lifted to Zod at registration). */

package/src/extensibility/custom-tools/wrapper.ts

@@ -15,6 +15,7 @@ export class CustomToolAdapter<TParams extends TSchema = TSchema, TDetails = any
 	declare description: string;
 	declare parameters: TParams;
 	readonly strict: boolean | undefined;
+	readonly concurrency: "shared" | "exclusive" | undefined;
 
 	constructor(
 		private tool: CustomTool<TParams, TDetails>,
@@ -22,6 +23,7 @@ export class CustomToolAdapter<TParams extends TSchema = TSchema, TDetails = any
 	) {
 		applyToolProxy(tool, this);
 		this.strict = tool.strict;
+		this.concurrency = tool.concurrency;
 	}
 
 	execute(

package/src/extensibility/extensions/types.ts

@@ -383,6 +383,8 @@ export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = un
 	description: string;
 	/** Parameter schema (Zod, or TypeBox for legacy/extension compat). */
 	parameters: TParams;
+	/** Tool scheduling mode; exclusive tools do not run in parallel with other tools in a model turn. */
+	concurrency?: "shared" | "exclusive";
 	/** If true, tool is excluded unless explicitly listed in --tools or agent's tools field */
 	hidden?: boolean;
 	/** If true, tool is registered but not auto-included in the initial active set.

package/src/extensibility/extensions/wrapper.ts

@@ -17,6 +17,7 @@ export class RegisteredToolAdapter implements AgentTool<any, any, any> {
 	declare parameters: any;
 	declare label: string;
 	declare strict: boolean;
+	declare concurrency: "shared" | "exclusive" | undefined;
 
 	renderCall?: (args: any, options: any, theme: any) => any;
 	renderResult?: (result: any, options: any, theme: any, args?: any) => any;