@gajae-code/coding-agent 0.6.4 → 0.6.5

package/dist/types/migrate/skill-normalizer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+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 declare function slugify(name: string): string;
+/**
+ * Produce a `{ slug, content }` pair whose effective GJC-loaded name equals `slug`.
+ * Throws only on an unusable name (cannot produce a slug).
+ */
+export declare function normalizeSkill(input: NormalizeSkillInput): NormalizedSkill;

package/dist/types/migrate/types.d.ts

@@ -0,0 +1,126 @@
+/**
+ * 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 declare const MIGRATE_SOURCES: readonly MigrateSource[];
+/** Canonical, deterministic ordering used when expanding `--from all` / repeated `--from`. */
+export declare const CANONICAL_SOURCE_ORDER: readonly MigrateSource[];
+/** 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 declare const MIGRATION_STATUSES: readonly MigrationStatus[];
+/** Statuses that represent a hard failure (drive `ok=false` + non-zero exit). */
+export declare const FAILURE_STATUSES: ReadonlySet<MigrationStatus>;
+export declare function isFailureStatus(status: MigrationStatus): boolean;
+/** 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 declare function emptyStatusCounts(): StatusCounts;

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,5 +1,5 @@
 import { Editor, type KeyId } from "@gajae-code/tui";
-import type { AppKeybinding } from "../../config/keybindings";
+import { type AppKeybinding } from "../../config/keybindings";
 type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.message.queue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
 type PastePendingClearReason = "timeout" | "queue-limit";
 /**

package/dist/types/modes/shared/agent-wire/unattended-audit.d.ts

@@ -41,7 +41,7 @@ export interface AuditLogOptions {
     now?(): number;
     nextId?(): string;
 }
-export declare function defaultAuditPath(runId: string, root?: string): string;
+export declare function defaultAuditPath(runId: string, root?: string, gjcSessionId?: string): string;
 /** Append-only audit log writer + reader for one unattended run. */
 export declare class UnattendedAuditLog {
     private readonly filePath;

package/dist/types/research-plan/index.d.ts

@@ -0,0 +1 @@
+export * from "./ledger";

package/dist/types/research-plan/ledger.d.ts

@@ -0,0 +1,33 @@
+export type ResearchPlanConfidence = "low" | "medium" | "high";
+export type ResearchEvidenceVerdict = "support" | "contradict" | "uncertain";
+export interface ResearchPlanItem {
+    claim: string;
+    confidence: ResearchPlanConfidence;
+    unknowns: string[];
+    evidenceNeeded: string[];
+    counterexampleQueries: string[];
+    sourceConflictPolicy: string;
+    dropCondition: string;
+    verifierChecks: string[];
+}
+export interface ResearchEvidenceEntry {
+    claim: string;
+    source: string;
+    confidence: ResearchPlanConfidence;
+    verdict: ResearchEvidenceVerdict;
+    notes?: string;
+}
+export interface ResearchLedgerVerdict {
+    claim: string;
+    finalVerdict: "accepted" | "rejected" | "uncertain";
+    survivingSources: ResearchEvidenceEntry[];
+    rejectReason?: string;
+    unresolvedUnknowns: string[];
+}
+export interface ResearchPlanValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export declare function validateResearchPlanItem(item: Partial<ResearchPlanItem>): ResearchPlanValidationResult;
+export declare function validateResearchEvidenceEntry(entry: Partial<ResearchEvidenceEntry>): ResearchPlanValidationResult;
+export declare function evaluateResearchLedger(item: ResearchPlanItem, evidence: readonly ResearchEvidenceEntry[]): ResearchLedgerVerdict;

package/dist/types/rlm/artifacts.d.ts

@@ -1,5 +1,5 @@
 import type { RlmArtifactPaths } from "./types";
-export declare const RLM_DIR_SEGMENT: string;
+export declare const RLM_DIR_SEGMENT = "rlm";
 export declare function isValidRlmSessionId(sessionId: string): boolean;
 /** Generate a filesystem-safe, sortable session id (timestamp + random suffix). */
 export declare function generateRlmSessionId(now?: Date): string;

package/dist/types/runtime-mcp/config-writer.d.ts

@@ -28,6 +28,32 @@ export declare function addMCPServer(filePath: string, name: string, config: MCP
  * @throws Error if validation fails
  */
 export declare function updateMCPServer(filePath: string, name: string, config: MCPServerConfig): Promise<void>;
+/**
+ * Result of an {@link upsertMCPServer} call.
+ * - `added`: server did not exist and was written.
+ * - `updated`: server existed and was overwritten because `force` was set.
+ * - `skipped`: server existed and `force` was not set, so nothing was written.
+ */
+export type UpsertMCPServerResult = {
+    status: "added";
+} | {
+    status: "updated";
+} | {
+    status: "skipped";
+    reason: "exists";
+};
+/**
+ * Add an MCP server, or overwrite an existing one only when `force` is set.
+ *
+ * Collision-aware wrapper over {@link addMCPServer} / {@link updateMCPServer} used by
+ * `gjc migrate`. Never connects to the server. Reuses the underlying writers so the
+ * rest of the config file (including `disabledServers`) is preserved on update.
+ *
+ * @throws Error if the server name or config is invalid (validated before any write).
+ */
+export declare function upsertMCPServer(filePath: string, name: string, config: MCPServerConfig, options?: {
+    force?: boolean;
+}): Promise<UpsertMCPServerResult>;
 /**
  * Remove an MCP server from a config file.
  *

package/dist/types/skill-state/active-state.d.ts

@@ -1,7 +1,7 @@
+import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill } from "./canonical-skills";
 import type { WorkflowStateReceipt } from "./workflow-state-contract";
 export declare const SKILL_ACTIVE_STATE_FILE = "skill-active-state.json";
-export declare const CANONICAL_GJC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
-export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];
+export { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill };
 export type WorkflowHudSeverity = "info" | "warning" | "blocked" | "error" | "success";
 export interface WorkflowHudChip {
     label: string;
@@ -44,6 +44,7 @@ export interface SkillActiveEntry {
     handoff_to?: string;
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
+    source_state_revision?: number;
 }
 export interface SkillActiveState {
     version?: number;
@@ -65,7 +66,7 @@ export interface SkillActiveState {
 }
 export interface SkillActiveStatePaths {
     rootPath: string;
-    sessionPath?: string;
+    sessionPath: string;
 }
 export interface SyncSkillActiveStateOptions {
     cwd: string;
@@ -83,6 +84,7 @@ export interface SyncSkillActiveStateOptions {
     handoff_to?: string;
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
+    sourceRevision?: number;
 }
 export declare function normalizeWorkflowHudSummary(raw: unknown): WorkflowHudSummary | undefined;
 export declare function isCanonicalGjcWorkflowSkill(skill: string): skill is CanonicalGjcWorkflowSkill;
@@ -102,13 +104,6 @@ export interface ApplyHandoffOptions {
     strict?: boolean;
 }
 /**
- * Atomically apply a workflow-skill handoff to both the session-scoped and
- * root `skill-active-state.json` files in a single write per file.
- *
- * Write order: **session first, root last**. The session file is the
- * source of truth for HUD; the root aggregate must never lead the session
- * during a handoff window. Each file is rewritten once with caller demoted
- * to `active:false` (preserving `handoff_to`/`handoff_at` lineage) and
- * callee promoted to `active:true` (with `handoff_from`/`handoff_at`).
+ * Atomically apply a workflow-skill handoff to the session-scoped active state.
  */
 export declare function applyHandoffToActiveState(options: ApplyHandoffOptions): Promise<void>;

package/dist/types/skill-state/canonical-skills.d.ts

@@ -0,0 +1,3 @@
+/** Native-free canonical GJC workflow skill identifiers. */
+export declare const CANONICAL_GJC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
+export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];

package/dist/types/skill-state/workflow-hud.d.ts

@@ -39,6 +39,8 @@ interface UltragoalHudState extends WorkflowGateHudState {
         event?: string;
         goalId?: string;
         timestamp?: string;
+        kind?: string;
+        evidence?: string;
     };
     updatedAt?: string;
 }

package/dist/types/task/spawn-gate.d.ts

@@ -1,6 +1,6 @@
 /** The hard, locked batch threshold enforced by the runtime gate. */
 export declare const DEFAULT_SPAWN_THRESHOLD = 4;
-/** The justification a large batch or reviewer-spawned explorer must supply to pass the hard gate. */
+/** The justification a large batch must supply to pass the hard gate. */
 export interface SpawnPlanReceipt {
     whyParallel: string;
     whyNotLocal: string;
@@ -14,14 +14,6 @@ export interface SpawnGateRequest {
     /** The spawn-plan receipt, when provided. */
     plan?: SpawnPlanReceipt;
 }
-export interface ReviewerExploreGateRequest {
-    /** Agent type/name doing the spawning, when known. */
-    spawningAgentType?: string | null;
-    /** Target agent type/name requested by the task call. */
-    targetAgent: string;
-    /** The spawn-plan receipt, when provided. */
-    plan?: SpawnPlanReceipt;
-}
 export type SpawnGateOutcome = "allowed" | "rejected";
 export interface SpawnGateDecision {
     outcome: SpawnGateOutcome;
@@ -35,4 +27,3 @@ export interface SpawnGateDecision {
 export declare function findMissingPlanFields(plan: SpawnPlanReceipt | undefined): string[];
 export declare function decide(childCount: number, threshold: number, plan: SpawnPlanReceipt | undefined): SpawnGateDecision;
 export declare function evaluateSpawnGate(request: SpawnGateRequest): SpawnGateDecision;
-export declare function evaluateReviewerExploreGate(request: ReviewerExploreGateRequest): SpawnGateDecision;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.6.4",
+	"version": "0.6.5",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -51,12 +51,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.6.4",
-		"@gajae-code/agent-core": "0.6.4",
-		"@gajae-code/ai": "0.6.4",
-		"@gajae-code/natives": "0.6.4",
-		"@gajae-code/tui": "0.6.4",
-		"@gajae-code/utils": "0.6.4",
+		"@gajae-code/stats": "0.6.5",
+		"@gajae-code/agent-core": "0.6.5",
+		"@gajae-code/ai": "0.6.5",
+		"@gajae-code/natives": "0.6.5",
+		"@gajae-code/tui": "0.6.5",
+		"@gajae-code/utils": "0.6.5",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/cli/migrate-cli.ts

@@ -0,0 +1,106 @@
+/**
+ * `gjc migrate` — import MCP servers and skills from other coding agents.
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+import { getAgentDir, getMCPConfigPath, getProjectAgentDir, getProjectDir } from "@gajae-code/utils";
+import { planMigration } from "../migrate/action-planner";
+import { getAdapter } from "../migrate/adapters/index";
+import { executeActions } from "../migrate/executor";
+import { buildReport, renderHuman } from "../migrate/report";
+import {
+	type AdapterResult,
+	CANONICAL_SOURCE_ORDER,
+	MIGRATE_SOURCES,
+	type MigrateDestinations,
+	type MigrateReport,
+	type MigrateSource,
+} from "../migrate/types";
+
+export interface MigrateCommandArgs {
+	from: string[];
+	project: boolean;
+	force: boolean;
+	dryRun: boolean;
+	json: boolean;
+	/** Test seam: override home dir for source discovery. */
+	homeDir?: string;
+	/** Test seam: override cwd for project-scope destinations. */
+	cwd?: string;
+}
+
+export class MigrateArgsError extends Error {}
+
+/** Expand `all`/repeated `--from`, validate, and return sources in canonical order. */
+export function resolveSources(from: string[]): MigrateSource[] {
+	if (from.length === 0) {
+		throw new MigrateArgsError("No source selected. Use --from <claude-code|codex|opencode|all> (repeatable).");
+	}
+	const selected = new Set<MigrateSource>();
+	for (const raw of from) {
+		const value = raw.trim().toLowerCase();
+		if (value === "all") {
+			for (const s of MIGRATE_SOURCES) selected.add(s);
+			continue;
+		}
+		if (!(MIGRATE_SOURCES as readonly string[]).includes(value)) {
+			throw new MigrateArgsError(`Unknown source "${raw}". Valid: ${MIGRATE_SOURCES.join(", ")}, all.`);
+		}
+		selected.add(value as MigrateSource);
+	}
+	return CANONICAL_SOURCE_ORDER.filter(s => selected.has(s));
+}
+
+function resolveDestinations(project: boolean, cwd: string): MigrateDestinations {
+	const scope = project ? "project" : "user";
+	const skillsDir = project ? path.join(getProjectAgentDir(cwd), "skills") : path.join(getAgentDir(), "skills");
+	return { mcpConfigPath: getMCPConfigPath(scope, cwd), skillsDir };
+}
+
+/** Run the migration and return the report (does not set process.exitCode). */
+export async function runMigrate(args: MigrateCommandArgs): Promise<MigrateReport> {
+	const sources = resolveSources(args.from);
+	const cwd = args.cwd ?? getProjectDir();
+	const homeDir = args.homeDir ?? os.homedir();
+	const destinations = resolveDestinations(args.project, cwd);
+
+	const results: AdapterResult[] = [];
+	for (const source of sources) {
+		results.push(await getAdapter(source).collect({ homeDir }));
+	}
+
+	const { actions, warnings } = await planMigration({ results, destinations, force: args.force });
+	const finalActions = args.dryRun ? actions : await executeActions(actions);
+
+	return buildReport({
+		actions: finalActions,
+		warnings,
+		sources,
+		destinations,
+		dryRun: args.dryRun,
+		project: args.project,
+		force: args.force,
+	});
+}
+
+/** CLI entry: run, render, and set the process exit code. */
+export async function runMigrateCommand(args: MigrateCommandArgs): Promise<void> {
+	let report: MigrateReport;
+	try {
+		report = await runMigrate(args);
+	} catch (error) {
+		if (error instanceof MigrateArgsError) {
+			process.stderr.write(`${error.message}\n`);
+			process.exitCode = 2;
+			return;
+		}
+		throw error;
+	}
+
+	if (args.json) {
+		process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+	} else {
+		process.stdout.write(`${renderHuman(report)}\n`);
+	}
+	process.exitCode = report.ok ? 0 : 1;
+}

package/src/cli.ts

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

package/src/commands/deep-interview.ts

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

package/src/commands/migrate.ts

@@ -0,0 +1,46 @@
+/**
+ * Import MCP servers and skills from other coding agents into GJC.
+ */
+import { Command, Flags } from "@gajae-code/utils/cli";
+import { type MigrateCommandArgs, runMigrateCommand } from "../cli/migrate-cli";
+
+export default class Migrate extends Command {
+	static description = "Import MCP servers and skills from Claude Code, Codex, or OpenCode";
+
+	static examples = [
+		"gjc migrate --from claude-code",
+		"gjc migrate --from codex --from opencode",
+		"gjc migrate --from all --dry-run --json",
+		"gjc migrate --from claude-code --project --force",
+	];
+
+	static flags = {
+		from: Flags.string({
+			description: "Source agent to import from (repeatable): claude-code | codex | opencode | all",
+			multiple: true,
+			required: true,
+		}),
+		project: Flags.boolean({
+			description: "Write to the project scope (./.gjc) instead of the user scope (~/.gjc)",
+			default: false,
+		}),
+		force: Flags.boolean({
+			description: "Overwrite existing skills/MCP servers instead of skipping them",
+			default: false,
+		}),
+		"dry-run": Flags.boolean({ description: "Preview the migration without writing anything", default: false }),
+		json: Flags.boolean({ char: "j", description: "Emit a machine-readable JSON report", default: false }),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Migrate);
+		const cmd: MigrateCommandArgs = {
+			from: flags.from ?? [],
+			project: flags.project,
+			force: flags.force,
+			dryRun: flags["dry-run"],
+			json: flags.json,
+		};
+		await runMigrateCommand(cmd);
+	}
+}

package/src/commands/state.ts

@@ -2,7 +2,8 @@ import { Command } from "@gajae-code/utils/cli";
 import { runNativeStateCommand } from "../gjc-runtime/state-runtime";
 
 export default class State extends Command {
-	static description = "Read or update GJC workflow state receipts under .gjc/state";
+	static description =
+		"Read or update current-session GJC workflow state receipts under .gjc/_session-{sessionid}/state";
 	static strict = false;
 	static examples = [
 		'$ gjc state read --input \'{"mode":"deep-interview"}\' --json',

package/src/commands/team.ts

@@ -75,7 +75,7 @@ function parseInputFlag(argv: string[]): Record<string, unknown> {
 
 export default class Team extends Command {
 	static description =
-		"Run native GJC tmux team orchestration from inside an existing tmux/GJC --tmux session; --dry-run writes ephemeral .gjc/state/team state only";
+		"Run native GJC tmux team orchestration from inside an existing tmux/GJC --tmux session; --dry-run writes ephemeral .gjc/_session-{sessionid}/state/team state only";
 	static strict = false;
 
 	static args = {
@@ -89,7 +89,7 @@ export default class Team extends Command {
 		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
 		"dry-run": Flags.boolean({
 			description:
-				"Create ephemeral .gjc/state/team state without starting tmux panes; do not commit generated state",
+				"Create ephemeral .gjc/_session-{sessionid}/state/team state without starting tmux panes; do not commit generated state",
 			default: false,
 		}),
 	};
@@ -210,7 +210,11 @@ export default class Team extends Command {
 			`tmux: ${snapshot.tmux_session}`,
 			`state: ${snapshot.state_dir}`,
 			`workers: ${snapshot.workers.length}`,
-			...(dryRun ? ["dry-run: wrote ephemeral .gjc/state/team state only; do not commit generated .gjc state"] : []),
+			...(dryRun
+				? [
+						"dry-run: wrote ephemeral .gjc/_session-{sessionid}/state/team state only; do not commit generated .gjc state",
+					]
+				: []),
 		]);
 	}
 }

package/src/coordinator-mcp/policy.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { coordinatorMcpStateRoot, gjcRoot } from "../gjc-runtime/session-layout";
 
 export type CoordinatorMutationClass = "sessions" | "questions" | "reports";
 
@@ -73,9 +74,16 @@ function cleanScope(value: string | undefined): string | null {
 	return trimmed.replace(/[^a-zA-Z0-9_.-]+/g, "-").slice(0, 100) || null;
 }
 
+function defaultCoordinatorMcpStateRoot(cwd: string, gjcSessionId?: string): string {
+	return gjcSessionId
+		? coordinatorMcpStateRoot(cwd, gjcSessionId)
+		: path.join(gjcRoot(cwd), "state", "coordinator-mcp");
+}
+
 export function buildCoordinatorMcpConfig(env: NodeJS.ProcessEnv = process.env): CoordinatorMcpConfig {
-	const stateRoot =
-		env.GJC_COORDINATOR_MCP_STATE_ROOT?.trim() || path.join(process.cwd(), ".gjc", "state", "coordinator-mcp");
+	const stateRootOverride = env.GJC_COORDINATOR_MCP_STATE_ROOT?.trim();
+	const gjcSessionId = env.GJC_SESSION_ID?.trim();
+	const stateRoot = stateRootOverride || defaultCoordinatorMcpStateRoot(process.cwd(), gjcSessionId);
 	return {
 		allowedRoots: parseRootList(env.GJC_COORDINATOR_MCP_WORKDIR_ROOTS).map(root => path.resolve(root)),
 		mutationClasses: parseMutationClasses(

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

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