@gajae-code/coding-agent 0.3.2 → 0.4.1

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/defaults/gjc/skills/deep-interview/SKILL.md

@@ -530,28 +530,24 @@ After the spec is written, mark it `pending approval` and present execution opti
 
 **Options:**
 
-1. **Refine with ralplan consensus (Recommended)**
-   - Description: "Consensus-refine this spec with Planner/Architect/Critic, then stop for explicit execution approval. Maximum quality."
-   - Action: Only after the user selects this option, invoke `/skill:ralplan --consensus --direct` with the spec file path as context. The `--direct` flag skips the ralplan skill's interview phase (the deep interview already gathered requirements), while `--consensus` triggers the Planner/Architect/Critic loop. When consensus completes and produces a plan in `.gjc/plans/`, stop with that plan marked `pending approval`; do not automatically invoke execution or any other execution skill.
-   - Pipeline: `deep-interview spec → explicit approval to refine → ralplan --consensus --direct → pending approval → separate execution approval`
+1. **Refine with ralplan consensus (Recommended — default for almost all specs)**
+   - Description: "Consensus-refine this spec with Planner/Architect/Critic, then stop for explicit execution approval. Maximum quality. Prefer this unless the spec is already implementation-ready and trivially simple."
+   - Action: Only after the user selects this option, invoke `/skill:ralplan` with the spec file path as context. Ralplan is already the Planner → Architect → Critic consensus workflow, so no extra slash-skill flags are required or supported. When consensus completes and produces a plan in `.gjc/plans/`, stop with that plan marked `pending approval`; do not automatically invoke execution or any other execution skill.
+   - Pipeline: `deep-interview spec → explicit approval to refine → ralplan → pending approval → separate execution approval`
 
-2. **Execute with team**
-   - Description: "Full autonomous pipeline — planning, parallel implementation, QA, validation. Faster but without consensus refinement."
-   - Action: Invoke `/skill:team` with the spec file path as context only after the user explicitly selects this execution option. The spec replaces team planning input.
+2. **Execute with ultragoal (only when spec is already implementation-ready and really simple)**
+   - Description: "Goal-tracked autonomous execution — drives the spec to completion with verification. Skip ralplan refinement only when the spec is concrete, low-risk, and trivially small."
+   - Action: Invoke `/skill:ultragoal` with the spec file path as context only after the user explicitly selects this execution option. The spec replaces ultragoal planning input. Recommend this only when the spec needs no further planning; otherwise route through ralplan refinement first.
 
-3. **Execute with team**
-   - Description: "Persistence loop with architect verification — keeps working until all acceptance criteria pass"
-   - Action: Invoke `/skill:team` with the spec file path as the task definition.
+3. **Execute with team (only when implementation-ready, simple, AND tmux parallelization is required)**
+   - Description: "N coordinated parallel agents in tmux — only when the spec is already implementation-ready and genuinely needs tmux-based interactive worker parallelization."
+   - Action: Invoke `/skill:team` with the spec file path as the shared plan only after the user explicitly selects this option. Reserve this for the narrow case where the spec is simple/ready and tmux interactive parallel workers are actually needed; otherwise prefer ralplan refinement, then ultragoal.
 
-4. **Execute with team**
-   - Description: "N coordinated parallel agents — fastest execution for large specs"
-   - Action: Invoke `/skill:team` with the spec file path as the shared plan.
-
-5. **Refine further**
+4. **Refine further**
    - Description: "Continue interviewing to improve clarity (current: {score}%)"
    - Action: Return to Phase 2 interview loop.
 
-**IMPORTANT:** On explicit execution selection, **MUST** use the chosen bundled GJC workflow skill entrypoint (`/skill:ralplan` or `/skill:team`) inside the agent session. `gjc ralplan` is a native CLI that accepts the documented skill flags and seeds local `.gjc/state` receipts; agent sessions should still drive the consensus loop through `/skill:ralplan`. `gjc team` is a native tmux runtime command and may be used only when the Team workflow explicitly requires the CLI runtime. Do NOT implement directly. The deep-interview agent is a requirements agent, not an execution agent. If oversized initial context was summarized, pass the spec and prompt-safe summary forward, not the raw oversized source material. Without explicit execution selection, stop with the spec marked `pending approval`.
+**IMPORTANT:** On explicit execution selection, **MUST** use the chosen bundled GJC workflow skill entrypoint (`/skill:ralplan`, `/skill:ultragoal`, or `/skill:team`) inside the agent session. `gjc ralplan` is a native CLI that accepts the documented skill flags and seeds local `.gjc/state` receipts; agent sessions should still drive the consensus loop through `/skill:ralplan`. Implementation handoff defaults to `/skill:ultragoal`; `/skill:team` is reserved for when tmux-based interactive worker parallelization is genuinely required, and `gjc team` is a native tmux runtime command used only when the Team workflow explicitly requires the CLI runtime. Do NOT implement directly. The deep-interview agent is a requirements agent, not an execution agent. If oversized initial context was summarized, pass the spec and prompt-safe summary forward, not the raw oversized source material. Without explicit execution selection, stop with the spec marked `pending approval`.
 
 ### Phase 5b: Handoff before chain
 
@@ -577,7 +573,7 @@ Stage 1: Deep Interview          Stage 2: ralplan consensus       Stage 3: Separ
 ┌─────────────────────┐    ┌───────────────────────────┐    ┌──────────────────────┐
 │ Socratic Q&A        │    │ Planner creates plan      │    │ User chooses if/how  │
 │ Ambiguity scoring   │───>│ Architect reviews         │───>│ execution proceeds   │
-│ Challenge agents    │    │ Critic validates          │    │ via team or ultragoal  │
+│ Challenge agents    │    │ Critic validates          │    │ via ultragoal (default) │
 │ Spec crystallization│    │ Loop until consensus      │    │ no auto-handoff      │
 │ Gate: ≤<resolvedThresholdPercent> ambiguity│    │ ADR + RALPLAN-DR summary  │    │                      │
 └─────────────────────┘    └───────────────────────────┘    └──────────────────────┘
@@ -604,7 +600,7 @@ Skipping any stage is possible but reduces quality assurance:
 - Round 0 topology confirmation happens before ambiguity scoring; Phase 2 scoring must honor locked topology and rotate targeting across active components when more than one is present
 - Use `gjc state write` / `gjc state read` for interview state persistence; the initial and subsequent deep-interview state payloads must include `threshold_source` alongside `threshold`; do not edit `.gjc/state` directly without force override.
 - Use the GJC workflow CLI to save the final spec at `.gjc/specs/deep-interview-{slug}.md` exactly; do not use `write`, `edit`, or `ast_edit` directly on `.gjc/` paths without force override.
-- Use public GJC workflow entrypoints to bridge to ralplan/team only after explicit execution approval — never implement directly
+- Use public GJC workflow entrypoints to bridge to ralplan, ultragoal, or team only after explicit execution approval — never implement directly. Implementation handoff defaults to ultragoal; reserve team for when tmux-based interactive worker parallelization is genuinely required.
 - Challenge agent modes are prompt injections, not separate agent spawns
 - Use internal fragment auto-modes only at their documented hooks: `auto-research-greenfield.md` between Step 2a and 2b for greenfield `research: true` questions, and `auto-answer-uncertain.md` as Step 2b′ after `ask` resolves and before scoring.
 - Fragment auto-modes are loaded on demand as `kind: "skill-fragment"`; they are not public workflow skills, not slash-command/discoverable, and not `skill://` registrations.
@@ -734,7 +730,7 @@ Why bad: 45% ambiguity means nearly half the requirements are unclear. The mathe
 - [ ] Spec includes: topology, goal, constraints, acceptance criteria, clarity breakdown, transcript
 - [ ] Execution bridge presented via the `ask` tool
 - [ ] Selected execution mode invoked via public GJC workflow entrypoint only after explicit execution approval (never direct implementation)
-- [ ] If 3-stage pipeline selected: ralplan --consensus --direct invoked, then stopped with the consensus plan marked `pending approval` until the user explicitly approves execution
+- [ ] If 3-stage pipeline selected: `/skill:ralplan` invoked with the spec as context, then stopped with the consensus plan marked `pending approval` until the user explicitly approves execution
 - [ ] State cleaned up after approved workflow handoff
 - [ ] Brownfield confirmation questions cite repo evidence (file/path/pattern) before asking the user to decide
 - [ ] Scope-fuzzy tasks can trigger ontology-style questioning to stabilize the core entity before feature elaboration
@@ -783,7 +779,7 @@ Team routing: "Your request is quite open-ended. Would you like to run a deep in
   [Yes, interview first] [No, expand directly]
 ```
 
-If the user chooses interview, team routing invokes `/skill:deep-interview`. When the interview completes and the user selects "Execute with team", the spec becomes Phase 0 output and team proceeds from the approved spec.
+If the user chooses interview, team routing invokes `/skill:deep-interview`. When the interview completes and the user selects an execution path (ultragoal by default, or team when tmux-based interactive parallelization is required), the spec becomes Phase 0 output and the chosen workflow proceeds from the approved spec.
 
 ## Approval-Gated Pipeline: deep-interview → ralplan → pending approval
 
@@ -794,17 +790,17 @@ The recommended refinement path chains clarity and feasibility gates, then stops
   → Socratic Q&A until ambiguity ≤ <resolvedThresholdPercent>
   → Spec written to .gjc/specs/deep-interview-{slug}.md
   → User explicitly selects "Refine with ralplan consensus"
-  → /skill:ralplan --consensus --direct (spec as input, skip interview)
+  → /skill:ralplan (spec as input)
     → Planner creates implementation plan from spec
     → Architect reviews for architectural soundness
     → Critic validates quality and testability
     → Loop until consensus (max 5 iterations)
     → Consensus plan written to .gjc/plans/
   → Stop with the consensus plan marked pending approval
-  → Only a separate explicit execution approval may invoke team or ultragoal
+  → Only a separate explicit execution approval may invoke execution (ultragoal by default; team only when tmux-based interactive worker parallelization is required)
 ```
 
-**The ralplan skill receives the spec with `--consensus --direct` flags** because the deep interview already did the requirements gathering. The `--direct` flag (supported by the ralplan skill, which ralplan aliases) skips the interview phase and goes straight to Planner → Architect → Critic consensus. The consensus plan includes:
+**The ralplan skill receives the spec as context through `/skill:ralplan`** because ralplan is already the GJC Planner → Architect → Critic consensus workflow. The consensus plan includes:
 - RALPLAN-DR summary (Principles, Decision Drivers, Options)
 - ADR (Decision, Drivers, Alternatives, Why chosen, Consequences)
 - Testable acceptance criteria (inherited from deep-interview spec)

package/src/defaults/gjc/skills/ralplan/SKILL.md

@@ -61,7 +61,7 @@ The consensus workflow:
    - Viable Options (>=2) with bounded pros/cons
    - If only one viable option remains, explicit invalidation rationale for alternatives
    - Deliberate mode only: pre-mortem (3 scenarios) + expanded test plan (unit/integration/e2e/observability)
-2. **User feedback** *(--interactive only)*: If `--interactive` is set, use `AskUserQuestion` to present the draft plan **plus the Principles / Drivers / Options summary** before review (Proceed to review / Request changes / Skip review). Otherwise, automatically proceed to review.
+2. **User feedback** *(--interactive only)*: If `--interactive` is set, use the `ask` tool to present the draft plan **plus the Principles / Drivers / Options summary** before review (Proceed to review / Request changes / Skip review). Otherwise, automatically proceed to review.
 3. **Architect** reviews for architectural soundness and must provide the strongest steelman antithesis, at least one real tradeoff tension, and (when possible) synthesis — **await completion before step 4**. In deliberate mode, Architect should explicitly flag principle violations.
    - The Architect agent/subagent must persist its review with `gjc ralplan --write --stage architect --stage_n <N> --artifact "..." --json`, then return the receipt/path plus compact verdict/status (`CLEAR`/`WATCH`/`BLOCK`, `APPROVE`/`COMMENT`/`REQUEST CHANGES`) instead of pasting the full review body.
 4. **Critic** evaluates against quality criteria — run only after step 3 completes. Critic must enforce principle-option consistency, fair alternatives, risk mitigation clarity, testable acceptance criteria, and concrete verification steps. In deliberate mode, Critic must reject missing/weak pre-mortem or expanded test plan.
@@ -74,9 +74,9 @@ The consensus workflow:
    d. Return to Critic evaluation
    e. Repeat this loop until Critic returns `APPROVE` or 5 iterations are reached
    f. If 5 iterations are reached without `APPROVE`, present the best version to the user
-6. On Critic approval, mark the plan `pending approval` unless explicit execution approval has already been captured, persist the ADR/final plan via `gjc ralplan --write --stage final --stage_n <N> --artifact "..."`, and do not directly edit `.gjc/plans`. *(--interactive only)* If `--interactive` is set, use `AskUserQuestion` to present the plan with approval options (Approve execution via team (Recommended) / Compact then return for execution approval / Request changes / Reject). Final plan must include ADR (Decision, Drivers, Alternatives considered, Why chosen, Consequences, Follow-ups). Otherwise, output the final plan and stop before any mutation or delegation.
-7. *(--interactive only)* User chooses: Approve team execution, Request changes, or Reject
-8. *(--interactive only)* On approval: invoke `/skill:team` for execution -- never implement directly
+6. On Critic approval, mark the plan `pending approval` unless explicit execution approval has already been captured, persist the ADR/final plan via `gjc ralplan --write --stage final --stage_n <N> --artifact "..."`, and do not directly edit `.gjc/plans`. *(--interactive only)* If `--interactive` is set, use the `ask` tool to present the plan with approval options (Approve execution via ultragoal (Recommended) / Approve execution via team (only when tmux-based interactive worker parallelization is required) / Compact then return for execution approval / Request changes / Reject). Final plan must include ADR (Decision, Drivers, Alternatives considered, Why chosen, Consequences, Follow-ups). Otherwise, output the final plan and stop before any mutation or delegation.
+7. *(--interactive only)* User chooses: Approve ultragoal execution (recommended), Approve team execution (tmux parallelization only), Request changes, or Reject
+8. *(--interactive only)* On approval: invoke `/skill:ultragoal` for execution by default; invoke `/skill:team` only when the user explicitly needs tmux-based interactive worker parallelization -- never implement directly
 
    Before invoking `/skill:team` or `/skill:ultragoal`, mark ralplan ready for handoff so the skill tool's chain guard permits the transition:
 
@@ -121,7 +121,7 @@ Set `--planner-resumable true` only when the parent session is provably persiste
 
 ### Why the Gate Exists
 
-Execution modes (team, team, team, team, team) spin up heavy multi-agent orchestration. When launched on a vague request like "team improve the app", agents have no clear target — they waste cycles on scope discovery that should happen during planning, often delivering partial or misaligned work that requires rework.
+Execution skills (`ultragoal` and `team`) drive implementation rather than scope discovery. When launched on a vague request like "team improve the app", agents have no clear target — they waste cycles on scope discovery that should happen during planning, often delivering partial or misaligned work that requires rework.
 
 The ralplan-first gate intercepts underspecified execution requests and redirects them through the ralplan consensus planning workflow. This ensures:
 - **Explicit scope**: A PRD defines exactly what will be built
@@ -177,8 +177,8 @@ The gate auto-passes when it detects **any** concrete signal. You do not need al
    - **Architect** reviews for soundness
    - **Critic** validates quality and testability
 5. On consensus approval, user chooses execution path:
-   - **team**: parallel coordinated agents (recommended)
-   - **team**: sequential execution with verification
+   - **ultragoal**: goal-tracked autonomous execution with verification (recommended default)
+   - **team**: N coordinated parallel agents in tmux — only when tmux-based interactive worker parallelization is required
 6. Execution begins with a clear, bounded plan
 
 ### Troubleshooting

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("");
+}