@gajae-code/coding-agent 0.7.10 → 0.8.0

package/src/discovery/windsurf.ts

@@ -6,93 +6,23 @@
  * - Project: .windsurf
  *
  * Supports:
- * - MCP servers from mcp_config.json
  * - Rules from .windsurf/rules/*.md and ~/.codeium/windsurf/memories/global_rules.md
  * - Legacy .windsurfrules file
+ *
+ * MCP servers are intentionally NOT inherited live from Windsurf config: GJC
+ * owns MCP runtime execution. Copy definitions into GJC's own mcp.json instead.
  */
 
-import { tryParseJson } from "@gajae-code/utils";
 import { registerProvider } from "../capability";
 import { readFile } from "../capability/fs";
-import { type MCPServer, mcpCapability } from "../capability/mcp";
 import { type Rule, ruleCapability } from "../capability/rule";
 import type { LoadContext, LoadResult } from "../capability/types";
-import {
-	buildRuleFromMarkdown,
-	createSourceMeta,
-	expandEnvVarsDeep,
-	getProjectPath,
-	getUserPath,
-	loadFilesFromDir,
-} from "./helpers";
+import { buildRuleFromMarkdown, createSourceMeta, getProjectPath, getUserPath, loadFilesFromDir } from "./helpers";
 
 const PROVIDER_ID = "windsurf";
 const DISPLAY_NAME = "Windsurf";
 const PRIORITY = 50;
 
-// =============================================================================
-// MCP Servers
-// =============================================================================
-
-function parseServerConfig(
-	name: string,
-	serverConfig: unknown,
-	path: string,
-	scope: "user" | "project",
-): { server?: MCPServer; warning?: string } {
-	if (typeof serverConfig !== "object" || serverConfig === null) {
-		return { warning: `Invalid server config for "${name}" in ${path}` };
-	}
-
-	const server = expandEnvVarsDeep(serverConfig as Record<string, unknown>);
-	return {
-		server: {
-			name,
-			command: server.command as string | undefined,
-			args: server.args as string[] | undefined,
-			env: server.env as Record<string, string> | undefined,
-			url: server.url as string | undefined,
-			headers: server.headers as Record<string, string> | undefined,
-			transport: server.type as "stdio" | "sse" | "http" | undefined,
-			timeout: typeof server.timeout === "number" ? server.timeout : undefined,
-			_source: createSourceMeta(PROVIDER_ID, path, scope),
-		},
-	};
-}
-
-async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
-	const items: MCPServer[] = [];
-	const warnings: string[] = [];
-
-	const userPath = getUserPath(ctx, "windsurf", "mcp_config.json");
-	const [userContent, projectPath] = await Promise.all([
-		userPath ? readFile(userPath) : Promise.resolve(null),
-		getProjectPath(ctx, "windsurf", "mcp_config.json"),
-	]);
-
-	const projectContent = projectPath ? await readFile(projectPath) : null;
-
-	const configs: Array<{ content: string | null; path: string | null; scope: "user" | "project" }> = [
-		{ content: userContent, path: userPath, scope: "user" },
-		{ content: projectContent, path: projectPath, scope: "project" },
-	];
-
-	for (const { content, path, scope } of configs) {
-		if (!content || !path) continue;
-
-		const config = tryParseJson<{ mcpServers?: Record<string, unknown> }>(content);
-		if (!config?.mcpServers) continue;
-
-		for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-			const result = parseServerConfig(name, serverConfig, path, scope);
-			if (result.warning) warnings.push(result.warning);
-			if (result.server) items.push(result.server);
-		}
-	}
-
-	return { items, warnings };
-}
-
 // =============================================================================
 // Rules
 // =============================================================================
@@ -130,14 +60,6 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 // Provider Registration
 // =============================================================================
 
-registerProvider<MCPServer>(mcpCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load MCP servers from Windsurf config (mcp_config.json)",
-	priority: PRIORITY,
-	load: loadMCPServers,
-});
-
 registerProvider<Rule>(ruleCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,

package/src/edit/read-file.ts

@@ -14,6 +14,13 @@ import { isNotebookPath, readEditableNotebookText, serializeEditedNotebookText }
  */
 export const MAX_EDIT_FILE_BYTES = 8 * 1024 * 1024;
 
+const UTF8_BOM = [0xef, 0xbb, 0xbf] as const;
+
+async function fileHasUtf8Bom(file: Bun.BunFile): Promise<boolean> {
+	const bytes = await file.slice(0, UTF8_BOM.length).bytes();
+	return UTF8_BOM.every((byte, index) => bytes[index] === byte);
+}
+
 export async function readEditFileText(absolutePath: string, path: string): Promise<string> {
 	try {
 		const file = Bun.file(absolutePath);
@@ -28,7 +35,8 @@ export async function readEditFileText(absolutePath: string, path: string): Prom
 		// Guard BEFORE the notebook fast-path: a >8 MiB .ipynb would otherwise load + JSON-parse
 		// + convert the whole file via readEditableNotebookText, bypassing the F19 freeze guard.
 		if (isNotebookPath(absolutePath)) return await readEditableNotebookText(absolutePath, path);
-		return await file.text();
+		const text = await file.text();
+		return (await fileHasUtf8Bom(file)) && !text.startsWith("\uFEFF") ? `\uFEFF${text}` : text;
 	} catch (error) {
 		if (isEnoent(error)) {
 			throw new Error(`File not found: ${path}`);

package/src/extensibility/extensions/runner.ts

@@ -347,7 +347,8 @@ export class ExtensionRunner {
 		"ctrl+t",
 		"ctrl+g",
 		"shift+tab",
-		"shift+ctrl+p",
+		"alt+n",
+		"alt+shift+n",
 		"ctrl+enter",
 		"alt+enter",
 		"escape",

package/src/gjc-runtime/launch-tmux.ts

@@ -37,6 +37,7 @@ export const GJC_TMUX_LAUNCHED_ENV = "GJC_TMUX_LAUNCHED";
 export const GJC_LAUNCH_POLICY_ENV = "GJC_LAUNCH_POLICY";
 export const GJC_TMUX_WINDOW_LABEL_MAX_WIDTH = 48;
 export const GJC_PSMUX_PROFILE_FORCE_ENV = "GJC_PSMUX_PROFILE_FORCE";
+const WINDOWS_PSMUX_ATTACH_RETRY_DELAY_MS = 100;
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
 type LaunchPolicy = "direct" | "tmux";
@@ -59,6 +60,7 @@ export interface TmuxLaunchContext {
 	tty?: TtyState;
 	spawnSync?: TmuxSpawnSync;
 	tmuxAvailable?: boolean;
+	tmuxStatusLines?: number;
 	worktreeBranch?: string | null;
 	currentBranch?: string | null;
 	existingBranchSessionName?: string | null;
@@ -107,6 +109,8 @@ export interface TmuxLaunchPlan {
 	project?: string | null;
 	sessionId?: string | null;
 	sessionStateFile?: string | null;
+	isPsmux: boolean;
+	platform: NodeJS.Platform;
 }
 
 function explicitTmuxSessionName(env: NodeJS.ProcessEnv): string | undefined {
@@ -117,7 +121,9 @@ function hasCurrentGjcVersion(session: GjcTmuxSessionStatus | undefined): boolea
 }
 
 function allowsExistingTmuxAttach(parsed: Args, env: NodeJS.ProcessEnv): boolean {
-	return Boolean(parsed.continue || parsed.resume || explicitTmuxSessionName(env));
+	// `--resume` belongs to the inner GJC session resolver. Let it reach main.ts so
+	// value-less resume can show the session picker and valued resume can honor the target.
+	return Boolean(parsed.continue || explicitTmuxSessionName(env));
 }
 
 function findExistingSessionForLaunch(context: {
@@ -544,42 +550,88 @@ function isTmuxAttachDisconnectError(result: TmuxSpawnResult): boolean {
 	const stderr = result.stderr?.toLowerCase() ?? "";
 	return stderr.includes("eio") || stderr.includes("input/output error");
 }
+function isWindowsPsmuxAttachConnectionRefused(plan: TmuxLaunchPlan, result: TmuxSpawnResult): boolean {
+	if (plan.platform !== "win32" || !plan.isPsmux) return false;
+	return result.stderr?.toLowerCase().includes("os error 10061") === true;
+}
+function waitForWindowsPsmuxAttachRetry(): void {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, WINDOWS_PSMUX_ATTACH_RETRY_DELAY_MS);
+}
 function normalizeTmuxTerminalDimension(value: number | undefined): number | undefined {
 	if (value === undefined || !Number.isSafeInteger(value) || value <= 0) return undefined;
 	return value;
 }
 
-function resolveCallerTmuxTerminalSize(tty: TtyState): TmuxTerminalSize | undefined {
+function normalizeTmuxStatusLineCount(value: number | undefined): number {
+	if (value === undefined || !Number.isSafeInteger(value) || value <= 0) return 0;
+	return value;
+}
+
+function parseTmuxStatusLineCount(value: string): number {
+	const normalized = value.trim().toLowerCase();
+	if (normalized.length === 0 || normalized === "off" || normalized === "0") return 0;
+	if (normalized === "on") return 1;
+	const parsed = Number.parseInt(normalized, 10);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : 1;
+}
+
+function readTmuxStatusLineCount(tmuxCommand: string, cwd: string, env: NodeJS.ProcessEnv): number {
+	const result = Bun.spawnSync([tmuxCommand, "show-options", "-gqv", "status"], {
+		cwd,
+		env,
+		stdin: "pipe",
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	if (result.exitCode !== 0) return 0;
+	return parseTmuxStatusLineCount(new TextDecoder().decode(result.stdout));
+}
+
+function resolveCallerTmuxTerminalSize(tty: TtyState, tmuxStatusLines = 0): TmuxTerminalSize | undefined {
 	if (!tty.stdout) return undefined;
 	const columns = normalizeTmuxTerminalDimension(tty.columns);
 	const rows = normalizeTmuxTerminalDimension(tty.rows);
 	if (columns === undefined || rows === undefined) return undefined;
-	return { columns, rows };
+	const adjustedRows = Math.max(1, rows - normalizeTmuxStatusLineCount(tmuxStatusLines));
+	return { columns, rows: adjustedRows };
 }
 
 function buildTmuxNewSessionSizeArgs(size: TmuxTerminalSize | undefined): string[] {
 	return size ? ["-x", String(size.columns), "-y", String(size.rows)] : [];
 }
 
-function resizeCreatedTmuxWindowToCallerTerminalSize(
+// Ensure the freshly created window fits the terminal that ultimately attaches.
+// `new-session` already starts the window (and the inner TUI) at the caller's
+// captured `-x/-y` size; this step governs what happens on `attach-session`.
+//
+// On native tmux we must NOT reassert with `resize-window`: that command flips
+// the window's `window-size` option to `manual`, pinning it to the capture-time
+// dimensions and stopping `attach-session` from resizing the window to the real
+// client. When the attaching terminal is larger than the capture — e.g. a GUI
+// terminal that reports a smaller size before it finishes sizing — the pinned
+// window stays small and tmux paints the uncovered client area with `·` fill
+// (the "window smaller than client" symptom). Keeping `window-size` on `latest`
+// lets tmux size the window to the attaching client (status line included).
+//
+// psmux (Windows) does not share tmux's `window-size` semantics, so preserve the
+// historical explicit `resize-window` reassert there rather than sending an
+// option its server may reject and echo into the user's pane.
+function ensureCreatedTmuxWindowTracksCallerTerminal(
 	plan: TmuxLaunchPlan,
 	spawnSync: TmuxSpawnSync,
 	options: TmuxSpawnOptions,
 ): void {
 	if (!plan.initialSize) return;
-	spawnSync(
-		plan.tmuxCommand,
-		[
-			"resize-window",
-			"-t",
-			buildGjcTmuxExactOptionTarget(plan.sessionName, { env: options.env }),
-			"-x",
-			String(plan.initialSize.columns),
-			"-y",
-			String(plan.initialSize.rows),
-		],
-		options,
-	);
+	const target = buildGjcTmuxExactOptionTarget(plan.sessionName, { env: options.env });
+	if (plan.isPsmux) {
+		spawnSync(
+			plan.tmuxCommand,
+			["resize-window", "-t", target, "-x", String(plan.initialSize.columns), "-y", String(plan.initialSize.rows)],
+			options,
+		);
+		return;
+	}
+	spawnSync(plan.tmuxCommand, ["set-window-option", "-t", target, "window-size", "latest"], options);
 }
 
 export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaunchPlan | undefined {
@@ -641,9 +693,14 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 		},
 		context.rawArgs,
 	);
-	const initialSize = resolveCallerTmuxTerminalSize(tty);
+	const tmuxStatusLines =
+		context.tmuxStatusLines ??
+		(context.tmuxAvailable === undefined ? readTmuxStatusLineCount(tmuxCommand, cwd, env) : 0);
+	const initialSize = resolveCallerTmuxTerminalSize(tty, tmuxStatusLines);
 	return {
 		tmuxCommand,
+		isPsmux: resolvedBinary.isPsmux,
+		platform,
 		sessionName,
 		cwd,
 		innerCommand,
@@ -742,6 +799,30 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 	const rootTerminalTitle = shouldSetGjcTmuxRootTerminalTitle(context.parsed, env)
 		? buildGjcTmuxRootTerminalTitle(plan.project ?? plan.cwd, plan.branch)
 		: undefined;
+	const buildProfileInputs = (): GjcTmuxProfileContext => ({
+		tmuxCommand: plan.tmuxCommand,
+		target: plan.sessionName,
+		cwd: plan.cwd,
+		env,
+		spawnSync,
+		branch: plan.branch,
+		project: plan.project,
+		sessionId: plan.sessionId ?? null,
+		sessionStateFile: plan.sessionStateFile ?? null,
+		version: VERSION,
+	});
+	const probeHasSession = (): TmuxSpawnResult =>
+		spawnSync(
+			plan.tmuxCommand,
+			["has-session", "-t", buildGjcTmuxExactSessionTarget(plan.sessionName, { env })],
+			probeOptions,
+		);
+	const attachCreatedSession = (): TmuxSpawnResult =>
+		spawnSync(
+			plan.tmuxCommand,
+			["attach-session", "-t", buildGjcTmuxExactSessionTarget(plan.sessionName, { env })],
+			attachOptions,
+		);
 
 	if (plan.attachSessionName) {
 		applyGjcTmuxRootTerminalTitleProfile({
@@ -767,24 +848,6 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 		// server first, and if the race fired, retry new-session before
 		// we hand the session to rename-window / applyGjcTmuxProfile so the
 		// profile-tagging path always sees a registered session.
-		const buildProfileInputs = (): GjcTmuxProfileContext => ({
-			tmuxCommand: plan.tmuxCommand,
-			target: plan.sessionName,
-			cwd: plan.cwd,
-			env,
-			spawnSync,
-			branch: plan.branch,
-			project: plan.project,
-			sessionId: plan.sessionId ?? null,
-			sessionStateFile: plan.sessionStateFile ?? null,
-			version: VERSION,
-		});
-		const probeHasSession = (): TmuxSpawnResult =>
-			spawnSync(
-				plan.tmuxCommand,
-				["has-session", "-t", buildGjcTmuxExactSessionTarget(plan.sessionName, { env })],
-				probeOptions,
-			);
 		const probeResult = probeHasSession();
 		if (probeResult.exitCode !== 0) {
 			const retry = spawnSync(plan.tmuxCommand, plan.newSessionArgs, newSessionOptions);
@@ -851,7 +914,7 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 			}
 			// Recovery succeeded via retry — fall through to attach-session below.
 		}
-		resizeCreatedTmuxWindowToCallerTerminalSize(plan, spawnSync, controlOptions);
+		ensureCreatedTmuxWindowTracksCallerTerminal(plan, spawnSync, controlOptions);
 		applyGjcTmuxRootTerminalTitleProfile({
 			tmuxCommand: plan.tmuxCommand,
 			target: plan.sessionName,
@@ -875,16 +938,75 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 		return false;
 	}
 	// attach-session needs PTY inherit for the user-facing attach; keep it unchanged.
-	const attached = spawnSync(
-		plan.tmuxCommand,
-		["attach-session", "-t", buildGjcTmuxExactSessionTarget(plan.sessionName, { env })],
-		attachOptions,
-	);
+	const attached = attachCreatedSession();
 	if (attached.exitCode === 0) return true;
 	if (isTmuxAttachDisconnectError(attached)) {
 		(context.diagnosticWriter ?? safeStderrWrite)(formatTmuxLaunchDiagnostic("attach disconnected", attached.stderr));
 		return true;
 	}
+	if (isWindowsPsmuxAttachConnectionRefused(plan, attached)) {
+		waitForWindowsPsmuxAttachRetry();
+		const probeAfterAttach = probeHasSession();
+		if (probeAfterAttach.exitCode === 0) {
+			const retryAttached = attachCreatedSession();
+			if (retryAttached.exitCode === 0) return true;
+			if (isTmuxAttachDisconnectError(retryAttached)) {
+				(context.diagnosticWriter ?? safeStderrWrite)(
+					formatTmuxLaunchDiagnostic("attach disconnected", retryAttached.stderr),
+				);
+				return true;
+			}
+		} else {
+			const retry = spawnSync(plan.tmuxCommand, plan.newSessionArgs, newSessionOptions);
+			const retryProbe = probeHasSession();
+			if (retry.exitCode === 0 && retryProbe.exitCode === 0) {
+				renameTmuxWindow(
+					plan.tmuxCommand,
+					windowTitle,
+					spawnSync,
+					controlOptions,
+					buildGjcTmuxExactSessionTarget(plan.sessionName, { env }),
+				);
+				const retryProfile = applyGjcTmuxProfile(buildProfileInputs());
+				const retryOwnershipFailure = retryProfile.failures.find(item =>
+					item.command.args.includes("@gjc-profile"),
+				);
+				if (!retryOwnershipFailure) {
+					ensureCreatedTmuxWindowTracksCallerTerminal(plan, spawnSync, controlOptions);
+					applyGjcTmuxRootTerminalTitleProfile({
+						tmuxCommand: plan.tmuxCommand,
+						target: plan.sessionName,
+						title: rootTerminalTitle,
+						spawnSync,
+						options,
+					});
+					const retryAttached = attachCreatedSession();
+					if (retryAttached.exitCode === 0) return true;
+					if (isTmuxAttachDisconnectError(retryAttached)) {
+						(context.diagnosticWriter ?? safeStderrWrite)(
+							formatTmuxLaunchDiagnostic("attach disconnected", retryAttached.stderr),
+						);
+						return true;
+					}
+				}
+			}
+		}
+	}
+	// Closing an SSH/Windows Terminal tab can make `tmux attach-session`
+	// exit with code 1 and no captured stderr while the tmux server correctly
+	// keeps the just-created session alive. Preserve that live session so the
+	// user can reattach instead of treating the parent client teardown as a
+	// launch failure.
+	const attachFailureStderr = attached.stderr?.trim() ?? "";
+	if (attachFailureStderr.length === 0) {
+		const probeAfterAttachFailure = probeHasSession();
+		if (probeAfterAttachFailure.exitCode === 0) {
+			(context.diagnosticWriter ?? safeStderrWrite)(
+				formatTmuxLaunchDiagnostic("attach disconnected", attached.stderr),
+			);
+			return true;
+		}
+	}
 	cleanupCreatedTmuxSession(plan, spawnSync, options);
 	(context.diagnosticWriter ?? safeStderrWrite)(formatTmuxLaunchDiagnostic("attach failed", attached.stderr));
 	return true;

package/src/gjc-runtime/ralplan-runtime.ts

@@ -11,7 +11,7 @@ import {
 	type RalplanIndexRow,
 	summarizeRalplanIndex,
 } from "./ledger-event-renderer";
-import { isRestrictedRoleAgentBash } from "./restricted-role-agent-bash";
+import { GJC_RALPLAN_ARTIFACT_ENV, isRestrictedRoleAgentBash } from "./restricted-role-agent-bash";
 import { modeStatePath, sessionPlansDir } from "./session-layout";
 import { resolveGjcSessionForWrite, writeSessionActivityMarker } from "./session-resolution";
 import { migrateWorkflowState } from "./state-migrations";
@@ -35,8 +35,9 @@ import {
  *    that lives in the bundled `/skill:ralplan` skill — but it accepts every documented flag so
  *    scripted users see a useful response and the active run is visible to the TUI.
  *
- * 2. **Artifact write**: `gjc ralplan --write --stage <type> --stage_n <N> --artifact
- *    <path-or-string> [--run-id <id>] [--session-id <id>] [--json]` persists Planner / Architect
+ * 2. **Artifact write**: `gjc ralplan --write --stage <type> --stage_n <N>
+ *    (--artifact <path-or-string> | --artifact-env GJC_RALPLAN_ARTIFACT)
+ *    [--run-id <id>] [--session-id <id>] [--json]` persists Planner / Architect
  *    / Critic / revision / post-interview / ADR / final markdown under `.gjc/plans/ralplan/<run-id>/`, maintains
  *    an `index.jsonl` audit log, copies `final` stages to `pending-approval.md`, and advances
  *    the HUD chip to reflect the latest persisted stage.
@@ -81,6 +82,7 @@ const VALUE_FLAGS = new Set([
 	"--stage",
 	"--stage_n",
 	"--artifact",
+	"--artifact-env",
 	"--run-id",
 	"--session-id",
 	"--architect",
@@ -409,8 +411,16 @@ async function resolveArtifactArgs(args: readonly string[], cwd: string): Promis
 	const stageN = parseStageN(flagValue(args, "--stage_n"));
 
 	const rawArtifact = flagValue(args, "--artifact");
-	if (rawArtifact === undefined || rawArtifact === "") {
-		throw new RalplanCommandError(2, "--artifact is required for ralplan --write");
+	const artifactEnvName = flagValue(args, "--artifact-env");
+	const artifactSources = [rawArtifact, artifactEnvName].filter(value => value !== undefined);
+	if (artifactSources.length === 0 || artifactSources.some(value => value === "")) {
+		throw new RalplanCommandError(2, "--artifact or --artifact-env is required for ralplan --write");
+	}
+	if (artifactSources.length > 1) {
+		throw new RalplanCommandError(2, "--artifact and --artifact-env are mutually exclusive");
+	}
+	if (artifactEnvName !== undefined && artifactEnvName !== GJC_RALPLAN_ARTIFACT_ENV) {
+		throw new RalplanCommandError(2, `--artifact-env must be ${GJC_RALPLAN_ARTIFACT_ENV}`);
 	}
 
 	const session = resolveGjcSessionForWrite(cwd, {
@@ -430,7 +440,13 @@ async function resolveArtifactArgs(args: readonly string[], cwd: string): Promis
 	const runId = explicitRunId || (await readActiveRunId(cwd, sessionId)) || sessionIdRaw || defaultRunId();
 	assertSafePathComponent(runId, "run-id");
 
-	const artifact = await resolveArtifactContent(rawArtifact, cwd);
+	const artifact =
+		artifactEnvName !== undefined
+			? (process.env[GJC_RALPLAN_ARTIFACT_ENV] ?? "")
+			: await resolveArtifactContent(rawArtifact!, cwd);
+	if (artifact === "") {
+		throw new RalplanCommandError(2, "artifact content is empty");
+	}
 	return { stage: stage as RalplanStage, stageN, runId, artifact, sessionId, json: hasFlag(args, "--json") };
 }
 

package/src/gjc-runtime/restricted-role-agent-bash.ts

@@ -1,4 +1,5 @@
 export const GJC_RESTRICTED_ROLE_AGENT_BASH_ENV = "GJC_RESTRICTED_ROLE_AGENT_BASH";
+export const GJC_RALPLAN_ARTIFACT_ENV = "GJC_RALPLAN_ARTIFACT";
 
 export function isRestrictedRoleAgentBash(): boolean {
 	return process.env[GJC_RESTRICTED_ROLE_AGENT_BASH_ENV] === "1";