@gajae-code/coding-agent 0.6.4 → 0.6.5

package/src/migrate/adapters/opencode.ts

@@ -0,0 +1,52 @@
+/**
+ * OpenCode adapter: reads `~/.config/opencode/opencode.json` (mcp), plus
+ * `~/.config/opencode/skills` and `~/.config/opencode/commands`.
+ */
+import * as path from "node:path";
+import type { AdapterResult, McpCandidate } from "../types";
+import {
+	type Adapter,
+	type AdapterOptions,
+	collectMarkdownPrompts,
+	collectSkillTree,
+	parseSourceJson,
+	readSourceText,
+} from "./index";
+
+const SOURCE = "opencode" as const;
+
+export const opencodeAdapter: Adapter = {
+	source: SOURCE,
+	async collect({ homeDir }: AdapterOptions): Promise<AdapterResult> {
+		const result: AdapterResult = { mcpCandidates: [], skillCandidates: [], diagnostics: [] };
+		const baseDir = path.join(homeDir, ".config", "opencode");
+
+		const configPath = path.join(baseDir, "opencode.json");
+		const read = await readSourceText(configPath, SOURCE, "mcp");
+		if ("diagnostic" in read) {
+			result.diagnostics.push(read.diagnostic);
+		} else {
+			const parsed = parseSourceJson(read.text, configPath, SOURCE, "mcp");
+			if ("diagnostic" in parsed) {
+				result.diagnostics.push(parsed.diagnostic);
+			} else {
+				const servers = parsed.data.mcp;
+				if (servers && typeof servers === "object" && !Array.isArray(servers)) {
+					for (const [name, raw] of Object.entries(servers as Record<string, unknown>)) {
+						result.mcpCandidates.push({ source: SOURCE, name, raw } satisfies McpCandidate);
+					}
+				}
+			}
+		}
+
+		const skills = await collectSkillTree(path.join(baseDir, "skills"), SOURCE);
+		result.skillCandidates.push(...skills.candidates);
+		result.diagnostics.push(...skills.diagnostics);
+
+		const commands = await collectMarkdownPrompts(path.join(baseDir, "commands"), SOURCE);
+		result.skillCandidates.push(...commands.candidates);
+		result.diagnostics.push(...commands.diagnostics);
+
+		return result;
+	},
+};

package/src/migrate/executor.ts

@@ -0,0 +1,81 @@
+/**
+ * Execute planned migration actions.
+ *
+ * Consumes the planner's actions unchanged and performs only `create`/`update`
+ * operations. It never re-plans. Writes are not transactional: on a write error
+ * the offending action flips to `failed_io`, already-written actions remain, and
+ * remaining actions still run (no rollback). Dry-run never calls this.
+ */
+import * as fsSync from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { upsertMCPServer } from "../runtime-mcp/config-writer";
+import type { MigrateAction } from "./types";
+
+async function ensureRealDirectoryPathNoFollow(directory: string): Promise<void> {
+	const resolved = path.resolve(directory);
+	const parsed = path.parse(resolved);
+	let current = parsed.root;
+	for (const part of resolved.slice(parsed.root.length).split(path.sep).filter(Boolean)) {
+		current = path.join(current, part);
+		try {
+			const stat = await fs.lstat(current);
+			if (!stat.isDirectory() || stat.isSymbolicLink()) {
+				throw new Error(`skill destination ancestor is not a real directory: ${current}`);
+			}
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+			await fs.mkdir(current);
+			const stat = await fs.lstat(current);
+			if (!stat.isDirectory() || stat.isSymbolicLink()) {
+				throw new Error(`skill destination ancestor is not a real directory: ${current}`);
+			}
+		}
+	}
+}
+
+async function writeSkillFileNoFollow(destination: string, content: string): Promise<void> {
+	const skillDir = path.dirname(destination);
+	await ensureRealDirectoryPathNoFollow(skillDir);
+	const handle = await fs.open(
+		destination,
+		fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_TRUNC | fsSync.constants.O_NOFOLLOW,
+		0o666,
+	);
+	try {
+		await handle.writeFile(content, "utf-8");
+	} finally {
+		await handle.close();
+	}
+}
+
+export async function executeActions(actions: MigrateAction[]): Promise<MigrateAction[]> {
+	const out: MigrateAction[] = [];
+	for (const action of actions) {
+		if (action.operation !== "create" && action.operation !== "update") {
+			out.push(action);
+			continue;
+		}
+		try {
+			if (action.type === "mcp" && action.mcp && action.name && action.destination) {
+				await upsertMCPServer(action.destination, action.name, action.mcp.config, {
+					force: action.operation === "update",
+				});
+				out.push(action);
+			} else if (action.type === "skill" && action.skill && action.destination) {
+				await writeSkillFileNoFollow(action.destination, action.skill.content);
+				out.push(action);
+			} else {
+				out.push(action);
+			}
+		} catch (error) {
+			out.push({
+				...action,
+				operation: "fail",
+				status: "failed_io",
+				reason: `write failed: ${(error as Error).message}`,
+			});
+		}
+	}
+	return out;
+}

package/src/migrate/mcp-mapper.ts

@@ -0,0 +1,152 @@
+/**
+ * Map raw source MCP server entries onto GJC `MCPServerConfig`.
+ *
+ * Implements the source-schema compatibility matrix from the consensus plan:
+ * preserved (P), transformed (T), omitted-with-warning (OW), skipped (S,
+ * `skipped_unmappable`), and failed (F, `failed_invalid_source`). Secret-indirection
+ * fields are always omitted-with-warning; their values are never read or emitted.
+ */
+import type { MCPServerConfig } from "../runtime-mcp/types";
+import type { MigrateSource } from "./types";
+
+export type McpMapOutcome =
+	| { ok: true; config: MCPServerConfig; warnings: string[] }
+	| { ok: false; status: "skipped_unmappable" | "failed_invalid_source"; reason: string };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function asStringArray(value: unknown): string[] | undefined | "invalid" {
+	if (value === undefined) return undefined;
+	if (!Array.isArray(value) || !value.every(v => typeof v === "string")) return "invalid";
+	return value as string[];
+}
+
+function asStringRecord(value: unknown): Record<string, string> | undefined | "invalid" {
+	if (value === undefined) return undefined;
+	if (!isRecord(value) || !Object.values(value).every(v => typeof v === "string")) return "invalid";
+	return value as Record<string, string>;
+}
+
+/** Secret-indirection fields per source: always omitted-with-warning, never read. */
+const SECRET_INDIRECTION_FIELDS: Record<MigrateSource, string[]> = {
+	"claude-code": [],
+	codex: ["env_vars", "env_http_headers", "bearer_token_env_var"],
+	opencode: [],
+};
+
+/** Fields recognized for a source (handled or intentionally omitted). Anything else is omitted-with-warning. */
+const RECOGNIZED_FIELDS: Record<MigrateSource, ReadonlySet<string>> = {
+	"claude-code": new Set(["type", "command", "args", "env", "url", "headers", "enabled", "timeout", "cwd"]),
+	codex: new Set([
+		"type",
+		"command",
+		"args",
+		"env",
+		"url",
+		"http_headers",
+		"cwd",
+		"enabled",
+		"timeout",
+		"tool_timeout_sec",
+		// omitted-with-warning fields are still "recognized" (handled below):
+		"env_vars",
+		"env_http_headers",
+		"bearer_token_env_var",
+		"startup_timeout_sec",
+		"enabled_tools",
+		"disabled_tools",
+	]),
+	opencode: new Set(["type", "command", "args", "env", "url", "headers", "enabled", "timeout", "cwd"]),
+};
+
+/** Fields with no GJC equivalent: omitted-with-warning (named explicitly so the warning is precise). */
+const OMITTED_FIELDS: Record<MigrateSource, string[]> = {
+	"claude-code": [],
+	codex: ["startup_timeout_sec", "enabled_tools", "disabled_tools"],
+	opencode: [],
+};
+
+export function mapMcpEntry(source: MigrateSource, name: string, raw: unknown): McpMapOutcome {
+	if (!isRecord(raw)) {
+		return { ok: false, status: "failed_invalid_source", reason: `server "${name}" is not an object` };
+	}
+
+	const warnings: string[] = [];
+	for (const field of SECRET_INDIRECTION_FIELDS[source]) {
+		if (field in raw) warnings.push(`omitted secret-indirection field "${field}" for "${name}" (value not read)`);
+	}
+	for (const field of OMITTED_FIELDS[source]) {
+		if (field in raw) warnings.push(`omitted unsupported field "${field}" for "${name}"`);
+	}
+	// Unknown/unrecognized fields: omit-with-warning (never copy their values).
+	for (const field of Object.keys(raw)) {
+		if (!RECOGNIZED_FIELDS[source].has(field)) {
+			warnings.push(`omitted unknown field "${field}" for "${name}"`);
+		}
+	}
+
+	const rawType = typeof raw.type === "string" ? raw.type : undefined;
+	const command = typeof raw.command === "string" ? raw.command : undefined;
+	const url = typeof raw.url === "string" ? raw.url : undefined;
+
+	const base: { enabled?: boolean; timeout?: number } = {};
+	if (typeof raw.enabled === "boolean") base.enabled = raw.enabled;
+	if (typeof raw.timeout === "number") base.timeout = raw.timeout;
+	// Codex tool_timeout_sec -> timeout (ms).
+	if (source === "codex" && typeof raw.tool_timeout_sec === "number") {
+		base.timeout = raw.tool_timeout_sec * 1000;
+	}
+
+	const wantsStdio =
+		source === "opencode" ? rawType === "local" || (!rawType && !!command) : !!command || rawType === "stdio";
+	const wantsHttp =
+		source === "opencode"
+			? rawType === "remote" || rawType === "sse"
+			: rawType === "http" || rawType === "sse" || (!command && !!url);
+
+	if (wantsStdio) {
+		if (!command) {
+			return {
+				ok: false,
+				status: "skipped_unmappable",
+				reason: `server "${name}" has no command for stdio transport`,
+			};
+		}
+		const args = asStringArray(raw.args);
+		if (args === "invalid") {
+			return { ok: false, status: "failed_invalid_source", reason: `server "${name}" has invalid "args"` };
+		}
+		const env = asStringRecord(raw.env);
+		if (env === "invalid") {
+			return { ok: false, status: "failed_invalid_source", reason: `server "${name}" has invalid "env"` };
+		}
+		const config: MCPServerConfig = { type: "stdio", command, ...base };
+		if (args) config.args = args;
+		if (env) config.env = env;
+		if (typeof raw.cwd === "string") config.cwd = raw.cwd;
+		return { ok: true, config, warnings };
+	}
+
+	if (wantsHttp) {
+		if (!url) {
+			return {
+				ok: false,
+				status: "skipped_unmappable",
+				reason: `server "${name}" has no url for http/sse transport`,
+			};
+		}
+		const headerSource = source === "codex" ? raw.http_headers : raw.headers;
+		const headers = asStringRecord(headerSource);
+		if (headers === "invalid") {
+			return { ok: false, status: "failed_invalid_source", reason: `server "${name}" has invalid headers` };
+		}
+		const type = rawType === "sse" ? "sse" : "http";
+		const config = { type, url, ...base } as MCPServerConfig;
+		if (headers) (config as { headers?: Record<string, string> }).headers = headers;
+		return { ok: true, config, warnings };
+	}
+
+	return { ok: false, status: "skipped_unmappable", reason: `server "${name}" has neither a usable command nor url` };
+}

package/src/migrate/report.ts

@@ -0,0 +1,104 @@
+/**
+ * Build the human-readable and `--json` reports for `gjc migrate`.
+ *
+ * Secret values are never read upstream, so the report only ever contains field
+ * names in warnings — but rendering still treats action/warning text as opaque.
+ */
+import {
+	emptyStatusCounts,
+	isFailureStatus,
+	type MigrateAction,
+	type MigrateDestinations,
+	type MigrateReport,
+	type MigrateSource,
+	type MigrateWarning,
+	type StatusCounts,
+} from "./types";
+
+export interface BuildReportInput {
+	actions: MigrateAction[];
+	warnings: MigrateWarning[];
+	sources: MigrateSource[];
+	destinations: MigrateDestinations;
+	dryRun: boolean;
+	project: boolean;
+	force: boolean;
+}
+
+export function buildReport(input: BuildReportInput): MigrateReport {
+	const total = emptyStatusCounts();
+	const byType = { mcp: emptyStatusCounts(), skill: emptyStatusCounts(), source: emptyStatusCounts() };
+	const bySource = {} as Record<MigrateSource, StatusCounts>;
+	for (const source of input.sources) bySource[source] = emptyStatusCounts();
+
+	let ok = true;
+	for (const action of input.actions) {
+		total[action.status] += 1;
+		byType[action.type][action.status] += 1;
+		if (bySource[action.source]) bySource[action.source][action.status] += 1;
+		if (isFailureStatus(action.status)) ok = false;
+	}
+
+	return {
+		ok,
+		dryRun: input.dryRun,
+		project: input.project,
+		force: input.force,
+		sources: input.sources,
+		destinations: input.destinations,
+		summary: { total, byType, bySource },
+		actions: input.actions.map(action => ({
+			source: action.source,
+			type: action.type,
+			name: action.name,
+			effectiveName: action.effectiveName,
+			destination: action.destination,
+			operation: action.operation,
+			status: action.status,
+			reason: action.reason,
+			warnings: action.warnings,
+		})),
+		warnings: input.warnings,
+	};
+}
+
+function summarizeCounts(counts: StatusCounts): string {
+	const parts: string[] = [];
+	for (const [status, count] of Object.entries(counts)) {
+		if (count > 0) parts.push(`${status}=${count}`);
+	}
+	return parts.length > 0 ? parts.join(", ") : "nothing";
+}
+
+export function renderHuman(report: MigrateReport): string {
+	const lines: string[] = [];
+	const mode = report.dryRun ? " (dry-run)" : "";
+	lines.push(`gjc migrate${mode}: ${report.ok ? "ok" : "completed with failures"}`);
+	lines.push(`Sources: ${report.sources.join(", ") || "none"}`);
+	lines.push(`Destination: mcp=${report.destinations.mcpConfigPath} skills=${report.destinations.skillsDir}`);
+	lines.push("");
+	lines.push(`MCP:    ${summarizeCounts(report.summary.byType.mcp)}`);
+	lines.push(`Skills: ${summarizeCounts(report.summary.byType.skill)}`);
+	if (Object.values(report.summary.byType.source).some(n => n > 0)) {
+		lines.push(`Source: ${summarizeCounts(report.summary.byType.source)}`);
+	}
+
+	const failures = report.actions.filter(a => isFailureStatus(a.status));
+	if (failures.length > 0) {
+		lines.push("");
+		lines.push("Failures:");
+		for (const f of failures) {
+			lines.push(`  - [${f.source}] ${f.type} ${f.name ?? ""}: ${f.status}${f.reason ? ` (${f.reason})` : ""}`);
+		}
+	}
+
+	if (report.warnings.length > 0) {
+		lines.push("");
+		lines.push("Warnings:");
+		for (const w of report.warnings) {
+			lines.push(`  - [${w.source}] ${w.type} ${w.name ?? ""}: ${w.message}`);
+		}
+	}
+
+	return lines.join("\n");
+}

package/src/migrate/skill-normalizer.ts

@@ -0,0 +1,80 @@
+/**
+ * Normalize a skill from another agent into a native GJC `SKILL.md`.
+ *
+ * GJC derives a skill's loaded name from its directory (`<slug>/SKILL.md`) when no
+ * frontmatter `name` is present, and requires a `description`. To guarantee the
+ * effective loaded name equals the lowercase-hyphen slug, we drop any frontmatter
+ * `name` and place the file at `<slug>/SKILL.md`, synthesizing a `description`
+ * when the source lacks one.
+ */
+
+import { parseFrontmatter } from "@gajae-code/utils";
+import { YAML } from "bun";
+
+export interface NormalizeSkillInput {
+	/** Raw name from the source (filename stem, frontmatter name, etc.). */
+	rawName: string;
+	/** Full source markdown (may or may not have frontmatter). */
+	content: string;
+}
+
+export interface NormalizedSkill {
+	slug: string;
+	content: string;
+	warnings: string[];
+}
+
+/** Convert an arbitrary name into a lowercase-hyphen slug. */
+export function slugify(name: string): string {
+	const slug = name
+		.normalize("NFKD")
+		.replace(/[^\w\s-]/g, "")
+		.trim()
+		.toLowerCase()
+		.replace(/[\s_]+/g, "-")
+		.replace(/-+/g, "-")
+		.replace(/^-+|-+$/g, "");
+	return slug;
+}
+
+function firstNonEmptyLine(body: string): string | undefined {
+	for (const raw of body.split("\n")) {
+		const line = raw.replace(/^#+\s*/, "").trim();
+		if (line) return line;
+	}
+	return undefined;
+}
+
+/**
+ * Produce a `{ slug, content }` pair whose effective GJC-loaded name equals `slug`.
+ * Throws only on an unusable name (cannot produce a slug).
+ */
+export function normalizeSkill(input: NormalizeSkillInput): NormalizedSkill {
+	const warnings: string[] = [];
+	const { frontmatter, body } = parseFrontmatter(input.content, { level: "off" });
+
+	const sourceName =
+		typeof frontmatter.name === "string" && frontmatter.name.trim() ? frontmatter.name : input.rawName;
+	const slug = slugify(sourceName);
+	if (!slug) {
+		throw new Error(`cannot derive a valid slug from skill name "${input.rawName}"`);
+	}
+	if (slugify(input.rawName) !== slug && typeof frontmatter.name === "string") {
+		warnings.push(`renamed skill "${input.rawName}" to slug "${slug}"`);
+	}
+
+	// Build the destination frontmatter: drop `name` (loaded name comes from the dir),
+	// keep other fields, and ensure a non-empty description.
+	const { name: _droppedName, description: rawDescription, ...rest } = frontmatter;
+	let description = typeof rawDescription === "string" ? rawDescription.trim() : "";
+	if (!description) {
+		description = firstNonEmptyLine(body) ?? `Imported ${slug} skill.`;
+		warnings.push(`synthesized description for skill "${slug}"`);
+	}
+
+	const fm: Record<string, unknown> = { description, ...rest };
+	const yaml = YAML.stringify(fm).trimEnd();
+	const content = `---\n${yaml}\n---\n\n${body.trim()}\n`;
+
+	return { slug, content, warnings };
+}

package/src/migrate/types.ts

@@ -0,0 +1,163 @@
+/**
+ * Shared types for `gjc migrate`.
+ *
+ * Imports MCP servers and skills from other coding agents (Claude Code, Codex,
+ * OpenCode) into native GJC config. See the consensus plan under
+ * `.gjc/plans/ralplan/` for the full taxonomy and force/collision semantics.
+ */
+import type { MCPServerConfig } from "../runtime-mcp/types";
+
+/** Supported migration sources. */
+export type MigrateSource = "claude-code" | "codex" | "opencode";
+
+export const MIGRATE_SOURCES: readonly MigrateSource[] = ["claude-code", "codex", "opencode"];
+
+/** Canonical, deterministic ordering used when expanding `--from all` / repeated `--from`. */
+export const CANONICAL_SOURCE_ORDER: readonly MigrateSource[] = MIGRATE_SOURCES;
+
+/** What kind of thing an action/coverage row is about. */
+export type MigrateItemType = "mcp" | "skill" | "source";
+
+/**
+ * Per-item outcome taxonomy.
+ *
+ * `skipped_*` outcomes are non-fatal (exit 0). Any `failed_*` outcome sets
+ * `ok=false` and a non-zero process exit code.
+ */
+export type MigrationStatus =
+	| "imported"
+	| "updated"
+	| "skipped_exists"
+	| "skipped_absent_source"
+	| "skipped_unmappable"
+	| "failed_invalid_source"
+	| "failed_invalid_destination"
+	| "failed_io";
+
+export const MIGRATION_STATUSES: readonly MigrationStatus[] = [
+	"imported",
+	"updated",
+	"skipped_exists",
+	"skipped_absent_source",
+	"skipped_unmappable",
+	"failed_invalid_source",
+	"failed_invalid_destination",
+	"failed_io",
+];
+
+/** Statuses that represent a hard failure (drive `ok=false` + non-zero exit). */
+export const FAILURE_STATUSES: ReadonlySet<MigrationStatus> = new Set<MigrationStatus>([
+	"failed_invalid_source",
+	"failed_invalid_destination",
+	"failed_io",
+]);
+
+export function isFailureStatus(status: MigrationStatus): boolean {
+	return FAILURE_STATUSES.has(status);
+}
+
+/** Operation the planner decided for an item. */
+export type MigrateOperation = "create" | "update" | "skip" | "fail";
+
+/** A raw MCP server candidate parsed from a source, before mapping/destination planning. */
+export interface McpCandidate {
+	source: MigrateSource;
+	name: string;
+	/** The raw, unmapped server entry from the source config (mapped by the planner). */
+	raw: unknown;
+}
+
+/** A raw skill candidate parsed from a source, before normalization/destination planning. */
+export interface SkillCandidate {
+	source: MigrateSource;
+	/** Slug used as the destination directory and effective loaded name. */
+	slug: string;
+	/** Full SKILL.md content (frontmatter already normalized so loaded name == slug). */
+	content: string;
+	warnings: string[];
+}
+
+/**
+ * Source-level diagnostic for a single source/type pair (e.g. "codex mcp config
+ * was malformed"). Distinct from per-item actions so absent/unreadable sources
+ * are reported once instead of per item.
+ */
+export interface SourceDiagnostic {
+	source: MigrateSource;
+	type: Exclude<MigrateItemType, "source"> | "source";
+	status: Extract<MigrationStatus, "skipped_absent_source" | "failed_invalid_source" | "failed_io">;
+	message: string;
+}
+
+/** Normalized candidates + diagnostics returned by an adapter. */
+export interface AdapterResult {
+	mcpCandidates: McpCandidate[];
+	skillCandidates: SkillCandidate[];
+	diagnostics: SourceDiagnostic[];
+}
+
+/** A single planned action consumed identically by dry-run and live execution. */
+export interface MigrateAction {
+	source: MigrateSource;
+	type: MigrateItemType;
+	name?: string;
+	/** For skills: the effective GJC-loaded name (== slug). */
+	effectiveName?: string;
+	/** Absolute destination path (mcp.json for MCP, <skillsDir>/<slug>/SKILL.md for skills). */
+	destination?: string;
+	operation: MigrateOperation;
+	status: MigrationStatus;
+	reason?: string;
+	warnings?: string[];
+	/** Resolved payload the executor needs; never serialized to the report. */
+	mcp?: { config: MCPServerConfig; force: boolean };
+	skill?: { content: string };
+}
+
+export interface MigrateWarning {
+	source: MigrateSource;
+	type: string;
+	name?: string;
+	message: string;
+}
+
+export type StatusCounts = Record<MigrationStatus, number>;
+
+export interface MigrateDestinations {
+	mcpConfigPath: string;
+	skillsDir: string;
+}
+
+/** The full machine-readable report emitted with `--json`. */
+export interface MigrateReport {
+	ok: boolean;
+	dryRun: boolean;
+	project: boolean;
+	force: boolean;
+	sources: MigrateSource[];
+	destinations: MigrateDestinations;
+	summary: {
+		total: StatusCounts;
+		byType: { mcp: StatusCounts; skill: StatusCounts; source: StatusCounts };
+		bySource: Record<MigrateSource, StatusCounts>;
+	};
+	actions: Array<{
+		source: MigrateSource;
+		type: MigrateItemType;
+		name?: string;
+		effectiveName?: string;
+		destination?: string;
+		operation: MigrateOperation;
+		status: MigrationStatus;
+		reason?: string;
+		warnings?: string[];
+	}>;
+	warnings: MigrateWarning[];
+}
+
+/** Create a zeroed status-count record. */
+export function emptyStatusCounts(): StatusCounts {
+	const counts = {} as StatusCounts;
+	for (const status of MIGRATION_STATUSES) counts[status] = 0;
+	return counts;
+}

package/src/modes/bridge/bridge-mode.ts

@@ -1,5 +1,5 @@
-import * as path from "node:path";
 import type { ExtensionUIContext } from "../../extensibility/extensions";
+import { workflowGatePath } from "../../gjc-runtime/session-layout";
 import type { AgentSession } from "../../session/agent-session";
 import type { ClientBridgePermissionOutcome } from "../../session/client-bridge";
 import type { RpcCommand, RpcResponse, RpcWorkflowGateResponse } from "../rpc/rpc-types";
@@ -611,7 +611,7 @@ export async function runBridgeMode(
 		});
 	};
 	const gateStore = new FileGateStore(
-		path.join(session.sessionManager.getCwd(), ".gjc", "state", "workflow-gates", `${session.sessionId}.json`),
+		workflowGatePath(session.sessionManager.getCwd(), session.sessionId, session.sessionId),
 	);
 	const unattendedControlPlane = new UnattendedSessionControlPlane({
 		runId: session.sessionId,