@gajae-code/coding-agent 0.3.2 → 0.4.0

package/src/config/settings-schema.ts

@@ -1,4 +1,4 @@
-import { THINKING_EFFORTS } from "@gajae-code/ai";
+import { THINKING_EFFORTS } from "@gajae-code/ai/model-thinking";
 import { TASK_SIMPLE_MODES } from "../task/simple-mode";
 import { getThinkingLevelMetadata } from "../thinking";
 import { EDIT_MODES } from "../utils/edit-mode";
@@ -2775,6 +2775,8 @@ export const SETTINGS_SCHEMA = {
 	"thinkingBudgets.high": { type: "number", default: 16384 },
 
 	"thinkingBudgets.xhigh": { type: "number", default: 32768 },
+
+	"thinkingBudgets.max": { type: "number", default: 65536 },
 } as const;
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -2955,6 +2957,7 @@ export interface ThinkingBudgetsSettings {
 	medium: number;
 	high: number;
 	xhigh: number;
+	max: number;
 }
 
 export interface SttSettings {

package/src/discovery/claude-plugins.ts

@@ -13,6 +13,7 @@ import { type Skill, skillCapability } from "../capability/skill";
 import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
 import { type CustomTool, toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult } from "../capability/types";
+import { rootContainsGjcManifest } from "../extensibility/gjc-plugins";
 import {
 	type ClaudePluginRoot,
 	createSourceMeta,
@@ -91,6 +92,25 @@ async function resolvePluginDir(
 	};
 }
 
+async function listNonGjcPluginRoots(
+	home: string,
+	cwd: string,
+): Promise<{ roots: ClaudePluginRoot[]; warnings: string[] }> {
+	const { roots, warnings } = await listClaudePluginRoots(home, cwd);
+	const filteredRoots: ClaudePluginRoot[] = [];
+	const filteredWarnings = [...warnings];
+
+	for (const root of roots) {
+		if (await rootContainsGjcManifest(root.path)) {
+			filteredWarnings.push(`[claude-plugins] Skipping gajae-code plugin root (binding-only): ${root.path}`);
+			continue;
+		}
+		filteredRoots.push(root);
+	}
+
+	return { roots: filteredRoots, warnings: filteredWarnings };
+}
+
 // =============================================================================
 // Skills
 // =============================================================================
@@ -99,7 +119,7 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	const items: Skill[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
 
 	const results = await Promise.all(
@@ -134,7 +154,7 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 	const items: SlashCommand[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
 
 	const results = await Promise.all(
@@ -174,7 +194,7 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 	const items: Hook[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
 
 	const hookTypes = ["pre", "post"] as const;
@@ -221,7 +241,7 @@ async function loadTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
 	const items: CustomTool[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
 
 	const results = await Promise.all(
@@ -258,7 +278,7 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 	const items: MCPServer[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
 
 	for (const root of roots) {

package/src/edit/diff.ts

@@ -4,6 +4,8 @@
  * Provides diff string generation and the replace-mode edit logic
  * used when not in patch mode.
  */
+
+import { createRequire } from "node:module";
 import * as Diff from "diff";
 import { resolveToCwd } from "../tools/path-utils";
 import { DEFAULT_FUZZY_THRESHOLD, EditMatchError, findMatch } from "./modes/replace";
@@ -54,12 +56,73 @@ function formatNumberedDiffLine(prefix: "+" | "-" | " ", lineNum: number, conten
 	return `${prefix}${lineNum}|${content}`;
 }
 
+type DiffLinePart = {
+	added?: boolean;
+	removed?: boolean;
+	value: string;
+};
+
+type DiffLinesFn = (oldStr: string, newStr: string) => DiffLinePart[];
+
+const require = createRequire(import.meta.url);
+const DIFF_LINES_TEST_OVERRIDE_UNSET = Symbol("DIFF_LINES_TEST_OVERRIDE_UNSET");
+
+let cachedNativeDiffLines: DiffLinesFn | null | undefined;
+let diffLinesTestOverride: DiffLinesFn | null | typeof DIFF_LINES_TEST_OVERRIDE_UNSET = DIFF_LINES_TEST_OVERRIDE_UNSET;
+
+function resolveNativeDiffLines(): DiffLinesFn | undefined {
+	if (diffLinesTestOverride !== DIFF_LINES_TEST_OVERRIDE_UNSET) {
+		return diffLinesTestOverride ?? undefined;
+	}
+
+	if (cachedNativeDiffLines !== undefined) {
+		return cachedNativeDiffLines ?? undefined;
+	}
+
+	try {
+		const natives = require("@gajae-code/natives") as { diffLines?: unknown };
+		cachedNativeDiffLines = typeof natives.diffLines === "function" ? (natives.diffLines as DiffLinesFn) : null;
+	} catch {
+		cachedNativeDiffLines = null;
+	}
+
+	return cachedNativeDiffLines ?? undefined;
+}
+
+function diffLinesWithFallback(oldContent: string, newContent: string): DiffLinePart[] {
+	const nativeDiffLines = resolveNativeDiffLines();
+	if (nativeDiffLines) {
+		try {
+			return nativeDiffLines(oldContent, newContent);
+		} catch {
+			// Fall through to the JS implementation if the native export fails at runtime.
+		}
+	}
+
+	return Diff.diffLines(oldContent, newContent);
+}
+
+export function __setDiffLinesForTest(diffLines: DiffLinesFn | null): void {
+	diffLinesTestOverride = diffLines;
+}
+
+export function __clearDiffLinesForTest(): void {
+	diffLinesTestOverride = DIFF_LINES_TEST_OVERRIDE_UNSET;
+	cachedNativeDiffLines = undefined;
+}
+
+export function __getNativeDiffLinesForTest(): DiffLinesFn | undefined {
+	return resolveNativeDiffLines();
+}
+
 /**
  * Generate a unified diff string with line numbers and context.
  * Returns both the diff string and the first changed line number (in the new file).
  */
 export function generateDiffString(oldContent: string, newContent: string, contextLines = 4): DiffResult {
-	const parts = Diff.diffLines(oldContent, newContent);
+	// Native line diff (Rust port of jsdiff `Diff.diffLines`, byte-identical
+	// output) — avoids the pure-JS Myers blowup (>1s on ~1MB files).
+	const parts = diffLinesWithFallback(oldContent, newContent);
 	const output: string[] = [];
 
 	let oldLineNum = 1;

package/src/edit/modes/replace.ts

@@ -21,6 +21,40 @@ import {
 	restoreLineEndings,
 	stripBom,
 } from "../normalize";
+
+type NativeBestFuzzyMatchResult = {
+	best?: FuzzyMatch;
+	aboveThresholdCount: number;
+	secondBestScore: number;
+};
+
+type NativeSequenceFuzzyResult = {
+	index?: number;
+	confidence: number;
+	matchCount: number;
+	matchIndices: number[];
+	secondBestScore: number;
+};
+
+let scoreSequenceFuzzyNative:
+	| ((lines: string[], pattern: string[], start: number, eof: boolean) => NativeSequenceFuzzyResult)
+	| undefined;
+let findBestFuzzyMatchNative:
+	| ((content: string, target: string, threshold: number) => NativeBestFuzzyMatchResult)
+	| undefined;
+void import("../../../../natives/native/index.js")
+	.then(mod => {
+		if (typeof mod.h02ScoreSequenceFuzzy === "function") {
+			scoreSequenceFuzzyNative = mod.h02ScoreSequenceFuzzy;
+		}
+		if (typeof mod.h01FindBestFuzzyMatch === "function") {
+			findBestFuzzyMatchNative = mod.h01FindBestFuzzyMatch;
+		}
+	})
+	.catch(() => {
+		// Native unavailable; fuzzy matching uses the TS fallback.
+	});
+
 import { readEditFileText, serializeEditFileText } from "../read-file";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
 
@@ -444,7 +478,7 @@ function findBestFuzzyMatchCore(
 	return { best, aboveThresholdCount, secondBestScore };
 }
 
-function findBestFuzzyMatch(content: string, target: string, threshold: number): BestFuzzyMatchResult {
+export function findBestFuzzyMatch(content: string, target: string, threshold: number): BestFuzzyMatchResult {
 	const contentLines = content.split("\n");
 	const targetLines = target.split("\n");
 
@@ -489,7 +523,8 @@ export function findMatch(
 
 	// Try fuzzy match
 	const threshold = options.threshold ?? DEFAULT_FUZZY_THRESHOLD;
-	const { best, aboveThresholdCount, secondBestScore } = findBestFuzzyMatch(content, target, threshold);
+	const { best, aboveThresholdCount, secondBestScore } =
+		findBestFuzzyMatchNative?.(content, target, threshold) ?? findBestFuzzyMatch(content, target, threshold);
 
 	if (!best) {
 		return {};
@@ -682,6 +717,29 @@ export function seekSequence(
 		return { index: undefined, confidence: 0 };
 	}
 
+	const nativeFuzzyResult = scoreSequenceFuzzyNative?.(lines, pattern, start, eof);
+	if (nativeFuzzyResult?.index !== undefined && nativeFuzzyResult.confidence >= SEQUENCE_FUZZY_THRESHOLD) {
+		if (
+			nativeFuzzyResult.matchCount > 1 &&
+			nativeFuzzyResult.confidence >= DOMINANT_FUZZY_MIN_CONFIDENCE &&
+			nativeFuzzyResult.confidence - nativeFuzzyResult.secondBestScore >= DOMINANT_FUZZY_DELTA
+		) {
+			return {
+				index: nativeFuzzyResult.index,
+				confidence: nativeFuzzyResult.confidence,
+				matchCount: 1,
+				matchIndices: nativeFuzzyResult.matchIndices,
+				strategy: "fuzzy-dominant",
+			};
+		}
+		return {
+			index: nativeFuzzyResult.index,
+			confidence: nativeFuzzyResult.confidence,
+			matchCount: nativeFuzzyResult.matchCount,
+			matchIndices: nativeFuzzyResult.matchIndices,
+			strategy: "fuzzy",
+		};
+	}
 	// Pass 7: Fuzzy matching - find best match above threshold
 	let bestScore = 0;
 	let secondBestScore = 0;

package/src/extensibility/gjc-plugins/activation.ts

@@ -0,0 +1,87 @@
+import { logger } from "@gajae-code/utils";
+import { loadGjcPlugins } from "./loader";
+import { discoverGjcPluginRoots } from "./paths";
+import { GjcPluginLoadError, type LoadedGjcPlugin, type LoadedSubskillActivation } from "./types";
+
+export interface SubskillActivationResult {
+	cleanedArgs: string;
+	activation?: LoadedSubskillActivation;
+	activeSubskillsToPersist: LoadedSubskillActivation[];
+}
+
+export async function resolveSubskillActivationForSkillInvocation(input: {
+	cwd: string;
+	sessionId?: string;
+	threadId?: string;
+	turnId?: string;
+	skillName: string;
+	args: string;
+}): Promise<SubskillActivationResult> {
+	const roots = await discoverGjcPluginRoots({ cwd: input.cwd });
+	let plugins: LoadedGjcPlugin[];
+	try {
+		plugins = await loadGjcPlugins(roots);
+	} catch (error) {
+		if (error instanceof GjcPluginLoadError) throw error;
+		logger.warn("Skipping GJC plugin activation set after load error", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		plugins = [];
+	}
+
+	const bindings = plugins.flatMap(plugin => plugin.bindings);
+	const activationsByArg = new Map<string, LoadedSubskillActivation>();
+	for (const binding of bindings) {
+		if (binding.parent !== input.skillName) continue;
+		activationsByArg.set(binding.activationArg, {
+			activationArg: binding.activationArg,
+			plugin: binding.plugin,
+			subskillName: binding.subskillName,
+			parent: binding.parent,
+			bindsTo: binding.bindsTo,
+			phase: binding.phase,
+			filePath: binding.filePath,
+			toolPaths: binding.toolPaths,
+		});
+	}
+
+	const tokens = input.args
+		.trim()
+		.split(/\s+/)
+		.filter(token => token.length > 0);
+	let activation: LoadedSubskillActivation | undefined;
+	const cleanedTokens: string[] = [];
+	let consumed = false;
+	for (const token of tokens) {
+		if (!consumed && token.startsWith("--") && !token.includes("=")) {
+			const candidate = activationsByArg.get(token.slice(2));
+			if (candidate) {
+				activation = candidate;
+				consumed = true;
+				continue;
+			}
+		}
+		cleanedTokens.push(token);
+	}
+
+	return {
+		cleanedArgs: consumed ? cleanedTokens.join(" ") : input.args,
+		activation,
+		activeSubskillsToPersist: activation
+			? bindings
+					.filter(
+						binding => binding.plugin === activation.plugin && binding.activationArg === activation.activationArg,
+					)
+					.map(binding => ({
+						activationArg: binding.activationArg,
+						plugin: binding.plugin,
+						subskillName: binding.subskillName,
+						parent: binding.parent,
+						bindsTo: binding.bindsTo,
+						phase: binding.phase,
+						filePath: binding.filePath,
+						toolPaths: binding.toolPaths,
+					}))
+			: [],
+	};
+}

package/src/extensibility/gjc-plugins/index.ts

@@ -0,0 +1,9 @@
+export * from "./activation";
+export * from "./injection";
+export * from "./loader";
+export * from "./paths";
+export * from "./schema";
+export * from "./state";
+export * from "./tools";
+export * from "./types";
+export * from "./validation";

package/src/extensibility/gjc-plugins/injection.ts

@@ -0,0 +1,114 @@
+import { readVisibleSkillActiveState } from "../../skill-state/active-state";
+import { initialPhaseForSkill } from "../../skill-state/initial-phase";
+import { readActiveSubskillsForParent } from "./state";
+import { GJC_SUBSKILL_PARENT_AGENTS, type LoadedSubskillActivation } from "./types";
+
+export async function readSubskillBody(filePath: string): Promise<string> {
+	const content = await Bun.file(filePath).text();
+	return content.replace(/^---\n[\s\S]*?\n---\n/, "").trim();
+}
+
+function escapeAttribute(value: string): string {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+export function wrapSubskillBlock(
+	activation: {
+		plugin: string;
+		subskillName: string;
+		parent: string;
+		phase: string;
+		activationArg: string;
+		filePath: string;
+	},
+	body: string,
+): string {
+	return `\n\n---\n\n<gjc-subskill plugin="${escapeAttribute(activation.plugin)}" name="${escapeAttribute(activation.subskillName)}" parent="${escapeAttribute(activation.parent)}" phase="${escapeAttribute(activation.phase)}" arg="${escapeAttribute(activation.activationArg)}">\n${body}\n</gjc-subskill>`;
+}
+
+export async function resolveCurrentPhaseForParent(input: {
+	cwd: string;
+	sessionId?: string;
+	parent: string;
+	explicitPhase?: string;
+}): Promise<string> {
+	const explicitPhase = input.explicitPhase?.trim();
+	if (explicitPhase) return explicitPhase;
+
+	const state = await readVisibleSkillActiveState(input.cwd, input.sessionId);
+	const persistedPhase = state?.active_skills?.find(entry => entry.skill === input.parent)?.phase?.trim();
+	if (persistedPhase) return persistedPhase;
+
+	if (state?.skill === input.parent) {
+		const statePhase = state.phase?.trim();
+		if (statePhase) return statePhase;
+	}
+
+	return initialPhaseForSkill(input.parent);
+}
+
+export async function buildSubskillInjection(input: {
+	cwd: string;
+	sessionId?: string;
+	skillName: string;
+	activation?: LoadedSubskillActivation;
+	currentPhase?: string;
+}): Promise<{ block: string; details?: LoadedSubskillActivation } | null> {
+	const resolvedPhase = await resolveCurrentPhaseForParent({
+		cwd: input.cwd,
+		sessionId: input.sessionId,
+		parent: input.skillName,
+		explicitPhase: input.currentPhase,
+	});
+
+	const directActivation = input.activation;
+	if (directActivation?.parent === input.skillName && directActivation.phase === resolvedPhase) {
+		const body = await readSubskillBody(directActivation.filePath);
+		return { block: wrapSubskillBlock(directActivation, body), details: directActivation };
+	}
+
+	const [entry] = await readActiveSubskillsForParent({
+		cwd: input.cwd,
+		sessionId: input.sessionId,
+		parent: input.skillName,
+		phase: resolvedPhase,
+	});
+	if (!entry) return null;
+
+	const activation: LoadedSubskillActivation = {
+		plugin: entry.plugin,
+		subskillName: entry.subskillName,
+		parent: entry.parent,
+		bindsTo: entry.bindsTo,
+		phase: entry.phase,
+		activationArg: entry.activationArg,
+		filePath: entry.filePath,
+		toolPaths: entry.toolPaths,
+	};
+	const body = await readSubskillBody(activation.filePath);
+	return { block: wrapSubskillBlock(activation, body), details: activation };
+}
+
+export async function buildAgentSubskillInjection(input: {
+	cwd: string;
+	sessionId?: string;
+	agentName: string;
+}): Promise<string> {
+	if (!(GJC_SUBSKILL_PARENT_AGENTS as readonly string[]).includes(input.agentName)) return "";
+
+	const entries = await readActiveSubskillsForParent({
+		cwd: input.cwd,
+		sessionId: input.sessionId,
+		parent: input.agentName,
+		phase: "prompt",
+	});
+	if (entries.length === 0) return "";
+
+	const blocks = await Promise.all(
+		entries.map(async entry => {
+			const body = await readSubskillBody(entry.filePath);
+			return wrapSubskillBlock(entry, body);
+		}),
+	);
+	return blocks.join("");
+}

package/src/extensibility/gjc-plugins/loader.ts

@@ -0,0 +1,131 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { parseFrontmatter } from "@gajae-code/utils";
+import { resolveWithinRoot } from "./paths";
+import { parseManifest, parseSubskillFrontmatter } from "./schema";
+import {
+	GJC_PLUGIN_MANIFEST_FILENAME,
+	GjcPluginLoadError,
+	type LoadedGjcPlugin,
+	type LoadedSubskillBinding,
+	type PhaseScopedToolBinding,
+} from "./types";
+import { buildParentArgMap, buildParentPhaseSet, validateBinding } from "./validation";
+
+async function readJsonFile(filePath: string): Promise<unknown> {
+	try {
+		return JSON.parse(await fs.readFile(filePath, "utf8")) as unknown;
+	} catch (error) {
+		if (error instanceof SyntaxError) {
+			throw new GjcPluginLoadError("invalid_manifest", `Invalid GJC plugin manifest JSON at ${filePath}`, {
+				cause: error,
+			});
+		}
+		throw new GjcPluginLoadError("missing_file", `Missing GJC plugin manifest at ${filePath}`, {
+			cause: error instanceof Error ? error : undefined,
+		});
+	}
+}
+
+async function readRequiredText(filePath: string, kind: "sub-skill" | "tool"): Promise<string> {
+	try {
+		return await fs.readFile(filePath, "utf8");
+	} catch (error) {
+		throw new GjcPluginLoadError("missing_file", `Missing GJC plugin ${kind} file at ${filePath}`, {
+			cause: error instanceof Error ? error : undefined,
+		});
+	}
+}
+
+function parseFrontmatterToolPaths(fm: Record<string, unknown>): string[] {
+	const raw = fm.tools;
+	if (raw === undefined) return [];
+	if (typeof raw === "string") return raw.trim() ? [raw] : [];
+	if (Array.isArray(raw) && raw.every(item => typeof item === "string")) return [...raw];
+	return [];
+}
+
+function pushToolBinding(
+	toolBindings: PhaseScopedToolBinding[],
+	plugin: string,
+	parent: string,
+	phase: string,
+	toolPath: string,
+): void {
+	toolBindings.push({ plugin, parent, phase, toolPath });
+}
+
+export async function loadGjcPlugin(root: string): Promise<LoadedGjcPlugin> {
+	const pluginRoot = path.resolve(root);
+	const manifestPath = path.join(pluginRoot, GJC_PLUGIN_MANIFEST_FILENAME);
+	const manifest = parseManifest(await readJsonFile(manifestPath), manifestPath);
+	const manifestToolPaths = manifest.tools.map(rel => resolveWithinRoot(pluginRoot, rel));
+
+	for (const toolPath of manifestToolPaths) {
+		await readRequiredText(toolPath, "tool");
+	}
+
+	const bindings: LoadedSubskillBinding[] = [];
+	const toolBindings: PhaseScopedToolBinding[] = [];
+
+	for (const rel of manifest.subskills) {
+		const filePath = resolveWithinRoot(pluginRoot, rel);
+		const content = await readRequiredText(filePath, "sub-skill");
+		let parsed: { frontmatter: Record<string, unknown>; body: string };
+		try {
+			parsed = parseFrontmatter(content, { source: filePath, level: "fatal" });
+		} catch (error) {
+			throw new GjcPluginLoadError("invalid_frontmatter", `Invalid GJC sub-skill frontmatter at ${filePath}`, {
+				cause: error instanceof Error ? error : undefined,
+			});
+		}
+		const frontmatter = parseSubskillFrontmatter(parsed.frontmatter, filePath);
+		validateBinding(frontmatter);
+		const frontmatterToolPaths = parseFrontmatterToolPaths(parsed.frontmatter).map(toolRel =>
+			resolveWithinRoot(pluginRoot, toolRel),
+		);
+		for (const toolPath of frontmatterToolPaths) {
+			await readRequiredText(toolPath, "tool");
+		}
+		const toolPaths = [...manifestToolPaths, ...frontmatterToolPaths];
+		const binding: LoadedSubskillBinding = {
+			plugin: manifest.name,
+			subskillName: frontmatter.name,
+			parent: frontmatter.binds_to,
+			bindsTo: frontmatter.binds_to,
+			phase: frontmatter.phase,
+			activationArg: frontmatter.activation_arg,
+			description: frontmatter.description,
+			filePath,
+			body: parsed.body,
+			toolPaths,
+		};
+		bindings.push(binding);
+		for (const toolPath of toolPaths) {
+			pushToolBinding(toolBindings, manifest.name, binding.parent, binding.phase, toolPath);
+		}
+	}
+
+	buildParentArgMap(bindings);
+	buildParentPhaseSet(bindings);
+
+	return {
+		name: manifest.name,
+		version: manifest.version,
+		root: pluginRoot,
+		manifestPath,
+		bindings,
+		toolBindings,
+	};
+}
+
+export async function loadGjcPlugins(roots: readonly string[]): Promise<LoadedGjcPlugin[]> {
+	const plugins: LoadedGjcPlugin[] = [];
+	for (const root of roots) {
+		plugins.push(await loadGjcPlugin(root));
+	}
+	const bindings = plugins.flatMap(plugin => plugin.bindings);
+	buildParentArgMap(bindings);
+	buildParentPhaseSet(bindings);
+	return plugins;
+}

package/src/extensibility/gjc-plugins/paths.ts

@@ -0,0 +1,66 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { getAgentDir, pathIsWithin } from "@gajae-code/utils";
+import { GJC_PLUGIN_MANIFEST_FILENAME, GjcPluginLoadError } from "./types";
+
+export function gjcPluginUserRoot(): string {
+	return path.join(getAgentDir(), "gjc-plugins");
+}
+
+export function gjcPluginProjectRoot(cwd: string): string {
+	return path.join(cwd, ".gjc", "gjc-plugins");
+}
+
+function isEnoent(error: unknown): boolean {
+	return (error as NodeJS.ErrnoException).code === "ENOENT";
+}
+
+export async function rootContainsGjcManifest(dir: string): Promise<boolean> {
+	try {
+		await fs.access(path.join(dir, GJC_PLUGIN_MANIFEST_FILENAME));
+		return true;
+	} catch (error) {
+		if (isEnoent(error)) return false;
+		throw error;
+	}
+}
+
+async function discoverGjcPluginRootsIn(baseDir: string): Promise<string[]> {
+	if (await rootContainsGjcManifest(baseDir)) return [baseDir];
+
+	let entries: import("node:fs").Dirent[];
+	try {
+		entries = await fs.readdir(baseDir, { withFileTypes: true });
+	} catch (error) {
+		if (isEnoent(error)) return [];
+		throw error;
+	}
+
+	const roots = await Promise.all(
+		entries
+			.filter(entry => entry.isDirectory() || entry.isSymbolicLink())
+			.map(async entry => {
+				const dir = path.join(baseDir, entry.name);
+				return (await rootContainsGjcManifest(dir)) ? dir : null;
+			}),
+	);
+
+	return roots.filter((root): root is string => root !== null);
+}
+
+export async function discoverGjcPluginRoots({ cwd }: { cwd: string; home?: string }): Promise<string[]> {
+	const roots = await Promise.all([
+		discoverGjcPluginRootsIn(gjcPluginUserRoot()),
+		discoverGjcPluginRootsIn(gjcPluginProjectRoot(cwd)),
+	]);
+	return roots.flat();
+}
+
+export function resolveWithinRoot(root: string, rel: string): string {
+	const resolvedRoot = path.resolve(root);
+	const resolvedPath = path.resolve(resolvedRoot, rel);
+	if (!pathIsWithin(resolvedRoot, resolvedPath)) {
+		throw new GjcPluginLoadError("missing_file", `GJC plugin path escapes root: ${rel}`);
+	}
+	return resolvedPath;
+}