@gajae-code/coding-agent 0.16.3 → 0.16.6

package/src/crash/sanitize.ts

@@ -40,7 +40,7 @@ const INVISIBLE_PATTERN = new RegExp(INVISIBLE_CLASS, "g");
 // residual scanner that silently alternates verdicts is worse than none.
 const CONTROL_PROBE = new RegExp(CONTROL_CLASS);
 const INVISIBLE_PROBE = new RegExp(INVISIBLE_CLASS);
-const URL_PATTERN = /\b[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^\s<>"'`)\]]+/g;
+const URL_PATTERN = /(?<![A-Za-z0-9+.-])[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^\s<>"'`)\]]+/g;
 /** Anything still matching these after sanitization means the scanner is not certain. */
 const RESIDUAL_PATTERNS: readonly RegExp[] = [
 	/\bsk-[A-Za-z0-9_-]{8,}/,

package/src/defaults/gjc/extensions/grok-cli-vendor/src/models/catalog.ts

@@ -73,6 +73,7 @@ const FALLBACK_MODELS: GrokCliModelConfig[] = [
     cost: COST_43,
     contextWindow: 1_000_000,
     maxTokens: 30_000,
+    maxReasoningEffort: Effort.High,
   },
   {
     // Official metadata and pricing: https://docs.x.ai/developers/models/grok-4.6
@@ -158,23 +159,22 @@ function matchesModelFamily(name: string, modelId: string): boolean {
   return name.startsWith(`${modelId}-`) && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(suffix);
 }
 
+const REASONING_EFFORT_CAPS = [
+  { prefix: 'grok-3-mini', max: Effort.High },
+  { prefix: 'grok-4.3', max: Effort.High },
+  { prefix: 'grok-4.5', max: Effort.High },
+  { prefix: 'grok-4.6', max: Effort.XHigh },
+  { prefix: 'grok-4.20-multi-agent', max: Effort.XHigh },
+] as const;
+
 export function getMaxReasoningEffort(modelId: string): Effort | undefined {
   const name = getCanonicalModelName(modelId);
-  return FALLBACK_MODELS.find((model) => matchesModelFamily(name, model.id.toLowerCase()))
-    ?.maxReasoningEffort;
+  return REASONING_EFFORT_CAPS.find(({ prefix }) => matchesModelFamily(name, prefix))?.max;
 }
 
-const EFFORT_CAPABLE_PREFIXES = [
-  'grok-3-mini',
-  'grok-4.20-multi-agent',
-  'grok-4.3',
-  'grok-4.5',
-  'grok-4.6',
-];
-
 export function supportsReasoningEffort(modelId: string): boolean {
   const name = getCanonicalModelName(modelId);
-  if (!EFFORT_CAPABLE_PREFIXES.some((prefix) => matchesModelFamily(name, prefix))) {
+  if (!REASONING_EFFORT_CAPS.some(({ prefix }) => matchesModelFamily(name, prefix))) {
     return false;
   }
   const model = resolveModels().find((entry) => getCanonicalModelName(entry.id) === name);

package/src/defaults/gjc/extensions/grok-cli-vendor/src/provider/register.ts

@@ -7,7 +7,12 @@ import { Effort } from '@gajae-code/ai/model-thinking';
 import type { OAuthCredentials, OAuthLoginCallbacks } from '@gajae-code/ai/utils/oauth/types';
 import { loginXai, refreshXaiToken, XAI_OAUTH_SCOPE } from '@gajae-code/ai/utils/oauth/xai';
 import type { ExtensionAPI, ProviderConfig } from '@gajae-code/coding-agent';
-import { type GrokCliModelConfig, resolveModels } from '../models/catalog.js';
+import {
+  type GrokCliModelConfig,
+  getMaxReasoningEffort,
+  resolveModels,
+  supportsReasoningEffort,
+} from '../models/catalog.js';
 import { sanitizePayload } from '../payload/sanitize.js';
 import { getBaseUrl, isGrokBuildBaseUrlOverrideIgnored } from '../shared/base-url.js';
 import { streamGrokCli } from './stream.js';
@@ -38,7 +43,7 @@ export default function registerGrokCli(api: ExtensionAPI) {
       thinking: m.reasoning
         ? {
             minLevel: Effort.Low,
-            maxLevel: m.maxReasoningEffort ?? Effort.XHigh,
+            maxLevel: getMaxReasoningEffort(m.id) ?? Effort.XHigh,
             mode: 'effort',
           }
         : undefined,
@@ -46,6 +51,12 @@ export default function registerGrokCli(api: ExtensionAPI) {
       cost: m.cost,
       contextWindow: m.contextWindow,
       maxTokens: m.maxTokens,
+      // cli-chat-proxy is not a generic audited OpenAI origin. Carry only the
+      // catalog's model-scoped evidence into core reasoning request gating.
+      compat:
+        m.reasoning && supportsReasoningEffort(m.id)
+          ? { supportsReasoningEffort: true }
+          : undefined,
     })),
     oauth: {
       name: 'Grok Build',

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

@@ -442,6 +442,28 @@ Receipts are freshness-scoped:
 - Appending required goals or changing final required-goal state stales final aggregate receipts. Final aggregate completion requires a fresh final aggregate receipt proving no incomplete, blocked, or `review_blocked` required goals remain.
 - Deferred per-goal receipts (validation-batch members) are incomplete until a matching fresh batch-close receipt exists on the batch's `finalGoalId`; a story-scope query for a deferred member stays blocked until that close, and mutating a member after close stales the batch-close and final aggregate receipts.
 
+## Cross-repository succession
+
+When an approved run was planned in one repository but the implementation belongs in another, the repository-binding guard correctly refuses to execute the plan from the second repository. Never edit `repositoryBinding` and never copy the runtime directory: both defeat the boundary and launder verification provenance. Use the explicit successor path instead.
+
+```
+gjc ultragoal succession offer --target-repo <path> --goal-id G002 --goal-id G003 --authorize "<who approved what, for which source, target and goals>" --authorized-by <identity> --json
+gjc ultragoal succession adopt --offer <offer path inside the source worktree> --json
+gjc ultragoal succession status --json
+```
+
+`offer` runs in the source repository. It records an offer document plus a durable outgoing ownership fence, and writes nothing to `brief.md`, `goals.json` or `ledger.jsonl`. From that moment the source run refuses to schedule or checkpoint the fenced goals; goals outside the selection stay fully schedulable. Ownership therefore leaves the source at the offer, not when the target happens to adopt, so no interval exists in which both runs may resume the same goal. There is deliberately no `revoke` verb: any read-then-delete of the fence races a concurrent adoption and could revive the source while the target is starting, so an unadopted offer keeps its goals fenced.
+
+Because unselected goals stay schedulable, ordinary source progress moves whole-file digests. Adoption therefore compares a **snapshot of the offered work** — the brief plus each selected goal's record and unresolved obligations — instead of whole-file equality, so unrelated progress cannot permanently strand the handed-off work. Whole-file digests are still recorded as provenance and any drift is written into the adoption record.
+
+`adopt` runs in the target repository and starts a genuinely fresh run: new pending goals, fresh timestamps, the target repository's own binding, and no inherited receipts, quality gates, validation batches, steering or activated objective. The source brief and every selected objective are carried verbatim, together with the unresolved obligations recorded against those goals — requirements are carried forward in full, never summarized down. Dependency groups travel as explicit obligations with source-to-target id mapping: the source's batch metadata and receipts are not inherited, but the requirement to validate those goals together is.
+
+Selection and authorization must be explicit. Only unfinished goals (`pending`, `failed`, `blocked`, `review_blocked`) may be handed off; the source run must be quiescent with no `active` goal; there is no implicit or wildcard selection; and a selection that takes only part of a validation batch, or splits a review blocker from the goal it still blocks, is rejected rather than silently dropping that obligation. Adoption fails closed on changed offered work, an altered or unfenced offer, an offer path that escapes the source worktree, a target the offer does not name, a linked worktree that is not the exact named target, an occupied target session, and any duplicate or simultaneous adoption anywhere in the target repository. A retry reconciles the exact recorded operation or fails closed — a matching operation id is never authority to overwrite target work it did not write, and a published plan that has disappeared is never reconstructed.
+
+Until publication completes, the target refuses to execute: a visible `goals.json` is not admission evidence, the adoption record is. `start`/`complete-goals` and `checkpoint` reject while an adoption remains pending.
+
+Integrity digests are evidence, not authorization: a matching digest set with no fence, no bounded authorization, or the wrong target is still rejected. Historical source statuses, receipts, reviews and approvals travel as provenance only and never satisfy a target gate.
+
 ## Handoff back to planning
 
 When the aggregate ultragoal is complete OR the user requests return to planning/clarification, mark ultragoal ready for handoff so the skill tool's chain guard permits the backward transition:

package/src/discovery/builtin.ts

@@ -28,8 +28,11 @@ import {
 	createSourceMeta,
 	discoverExtensionModulePaths,
 	expandEnvVarsDeep,
+	getAncestorDirs,
 	getExtensionNameFromPath,
+	getUserSkillScanDirs,
 	loadFilesFromDir,
+	readContainedFile,
 	SOURCE_PATHS,
 	scanSkillsFromDir,
 } from "./helpers";
@@ -41,10 +44,6 @@ const PRIORITY = 100;
 
 const PATHS = SOURCE_PATHS.native;
 
-function getUserAgentDirs(): string[] {
-	return [PATHS.userAgent];
-}
-
 /**
  * GJC's user-scope config directory.
  *
@@ -92,26 +91,12 @@ async function getConfigDirs(ctx: LoadContext): Promise<Array<{ dir: string; lev
 	return result;
 }
 
-function getAncestorDirs(cwd: string, stopAt?: string | null): Array<{ dir: string; depth: number }> {
-	const ancestors: Array<{ dir: string; depth: number }> = [];
-	let current = cwd;
-	let depth = 0;
-	while (true) {
-		ancestors.push({ dir: current, depth });
-		if (stopAt && current === stopAt) break;
-		const parent = path.dirname(current);
-		if (parent === current) break;
-		current = parent;
-		depth++;
-	}
-	return ancestors;
-}
-
 async function findNearestProjectConfigDir(
 	cwd: string,
 	repoRoot?: string | null,
+	home?: string,
 ): Promise<{ dir: string; depth: number } | null> {
-	for (const ancestor of getAncestorDirs(cwd, repoRoot)) {
+	for (const ancestor of getAncestorDirs(cwd, repoRoot ?? home, home)) {
 		for (const projectConfigDir of getProjectConfigDirs()) {
 			const configDir = await ifNonEmptyDir(ancestor.dir, projectConfigDir);
 			if (configDir) return { dir: configDir, depth: ancestor.depth };
@@ -280,20 +265,21 @@ registerProvider<MCPServer>(mcpCapability.id, {
 async function loadSystemPrompt(ctx: LoadContext): Promise<LoadResult<SystemPrompt>> {
 	const items: SystemPrompt[] = [];
 
-	for (const userAgentDir of getUserAgentDirs()) {
-		const userPath = path.join(ctx.home, userAgentDir, "SYSTEM.md");
-		const userContent = await readFile(userPath);
-		if (userContent) {
-			items.push({
-				path: userPath,
-				content: userContent,
-				level: "user",
-				_source: createSourceMeta(PROVIDER_ID, userPath, "user"),
-			});
-		}
+	// User scope is the agent directory — the directory `gjc config path` prints
+	// and the only user-scope seam. A profile is a separate scope; the default
+	// profile's home-relative SYSTEM.md is not read under one.
+	const userPath = path.join(resolveUserAgentDir(ctx), "SYSTEM.md");
+	const userContent = await readContainedFile(resolveUserAgentDir(ctx), userPath);
+	if (userContent) {
+		items.push({
+			path: userPath,
+			content: userContent,
+			level: "user",
+			_source: createSourceMeta(PROVIDER_ID, userPath, "user"),
+		});
 	}
 
-	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot);
+	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot, ctx.home);
 	if (nearestProjectConfigDir) {
 		const projectPath = path.join(nearestProjectConfigDir.dir, "SYSTEM.md");
 		const projectContent = await readFile(projectPath);
@@ -321,7 +307,7 @@ registerProvider<SystemPrompt>(systemPromptCapability.id, {
 // Skills
 async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	// Walk up from cwd finding .gjc/skills/ in ancestors (closest first)
-	const ancestors = getAncestorDirs(ctx.cwd, ctx.repoRoot ?? ctx.home);
+	const ancestors = getAncestorDirs(ctx.cwd, ctx.repoRoot ?? ctx.home, ctx.home);
 	const projectScans = ancestors.flatMap(({ dir }) =>
 		getProjectConfigDirs().map(projectConfigDir =>
 			scanSkillsFromDir(ctx, {
@@ -333,15 +319,18 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 		),
 	);
 
-	// User-level scan from the active agent-directory profile.
-	const userScans = [
+	// User-level scan from the selected agent-directory profile plus documented
+	// default-profile legacy scan roots.
+	const userAgentDir = resolveUserAgentDir(ctx);
+	const userScans = getUserSkillScanDirs(ctx.home, userAgentDir, ctx.profileAuthority).map(dir =>
 		scanSkillsFromDir(ctx, {
-			dir: path.join(resolveUserAgentDir(ctx), "skills"),
+			dir,
+			authorityRoot: path.resolve(dir) === path.resolve(userAgentDir, "skills") ? userAgentDir : undefined,
 			providerId: PROVIDER_ID,
 			level: "user",
 			requireDescription: true,
 		}),
-	];
+	);
 
 	const results = await Promise.all([...projectScans, ...userScans]);
 
@@ -395,28 +384,36 @@ registerProvider<SlashCommand>(slashCommandCapability.id, {
 async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 	const items: Rule[] = [];
 	const warnings: string[] = [];
-
-	for (const { dir, level } of await getConfigDirs(ctx)) {
-		const rulesDir = path.join(dir, "rules");
-		const result = await loadFilesFromDir<Rule>(ctx, rulesDir, PROVIDER_ID, level, {
-			extensions: ["md", "mdc"],
-			transform: (name, content, path, source) =>
-				buildRuleFromMarkdown(name, content, path, source, { stripNamePattern: /\.(md|mdc)$/ }),
-		});
-		items.push(...result.items);
-		if (result.warnings) warnings.push(...result.warnings);
-	}
+	const configDirs = await getConfigDirs(ctx);
+	const projectConfigDirs = configDirs.filter(({ level }) => level === "project");
+	const userConfigDirs = configDirs.filter(({ level }) => level === "user");
+
+	const loadRulesFromDirs = async (dirs: Array<{ dir: string; level: "user" | "project" }>) => {
+		for (const { dir, level } of dirs) {
+			const rulesDir = path.join(dir, "rules");
+			const result = await loadFilesFromDir<Rule>(ctx, rulesDir, PROVIDER_ID, level, {
+				extensions: ["md", "mdc"],
+				transform: (name, content, path, source) =>
+					buildRuleFromMarkdown(name, content, path, source, { stripNamePattern: /\.(md|mdc)$/ }),
+			});
+			items.push(...result.items);
+			if (result.warnings) warnings.push(...result.warnings);
+		}
+	};
 
 	// Top-level RULES.md is a sticky always-apply rule. The context-file
 	// discovery contract treats it as the file "re-injected near the current
 	// turn so they keep hold across long conversations".
-	// User scope:    ~/.gjc/agent/RULES.md
+	// User scope:    <agentDir>/RULES.md (a profile is a separate user scope;
+	//                the default profile's home-relative copy is not read)
 	// Project scope: nearest .gjc/RULES.md walking up from cwd to repoRoot
+	await loadRulesFromDirs([...projectConfigDirs, ...userConfigDirs]);
+
 	const userRulesFile = path.join(resolveUserAgentDir(ctx), "RULES.md");
 	const userRule = await loadStickyRulesFile(userRulesFile, "user");
 	if (userRule) items.push(userRule);
 
-	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot);
+	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot, ctx.home);
 	if (nearestProjectConfigDir) {
 		const projectRulesFile = path.join(nearestProjectConfigDir.dir, "RULES.md");
 		const projectRule = await loadStickyRulesFile(projectRulesFile, "project");
@@ -431,7 +428,7 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
  * Returns null when the file is absent or empty so callers can short-circuit.
  */
 async function loadStickyRulesFile(filePath: string, level: "user" | "project"): Promise<Rule | null> {
-	const content = await readFile(filePath);
+	const content = await readContainedFile(path.dirname(filePath), filePath);
 	if (!content) return null;
 	const source = createSourceMeta(PROVIDER_ID, filePath, level);
 	const rule = buildRuleFromMarkdown("RULES.md", content, filePath, source, { ruleName: "RULES" });
@@ -719,7 +716,7 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 		const { typeDir, hookType, level } = typeDirRequests[i];
 		const typeEntries = typeEntriesResults[i];
 
-		for (const entry of typeEntries) {
+		for (const entry of [...typeEntries].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))) {
 			if (entry.name.startsWith(".")) continue;
 			if (!entry.isFile()) continue;
 
@@ -929,8 +926,8 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 	const items: ContextFile[] = [];
 	const warnings: string[] = [];
 
-	const userPath = path.join(ctx.home, PATHS.userAgent, "AGENTS.md");
-	const userContent = await readFile(userPath);
+	const userPath = path.join(resolveUserAgentDir(ctx), "AGENTS.md");
+	const userContent = await readContainedFile(resolveUserAgentDir(ctx), userPath);
 	if (userContent) {
 		items.push({
 			path: userPath,
@@ -940,7 +937,7 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 		});
 	}
 
-	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot);
+	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot, ctx.home);
 	if (nearestProjectConfigDir) {
 		const projectPath = path.join(nearestProjectConfigDir.dir, "AGENTS.md");
 		const projectContent = await readFile(projectPath);

package/src/discovery/claude-plugins.ts

@@ -17,6 +17,7 @@ import { rootContainsGjcManifest } from "../extensibility/gjc-plugins";
 import {
 	type ClaudePluginRoot,
 	createSourceMeta,
+	invalidateClaudePluginRoots,
 	listClaudePluginRoots,
 	loadFilesFromDir,
 	scanSkillsFromDir,
@@ -95,12 +96,15 @@ async function resolvePluginDir(
 async function listNonGjcPluginRoots(
 	home: string,
 	cwd: string,
+	allowedLevels: ReadonlySet<"user" | "project"> = new Set(["user", "project"]),
 ): Promise<{ roots: ClaudePluginRoot[]; warnings: string[] }> {
+	await invalidateClaudePluginRoots(home, cwd);
 	const { roots, warnings } = await listClaudePluginRoots(home, cwd);
 	const filteredRoots: ClaudePluginRoot[] = [];
-	const filteredWarnings = [...warnings];
+	const filteredWarnings = allowedLevels.size === 2 ? [...warnings] : [];
 
 	for (const root of roots) {
+		if (!allowedLevels.has(root.scope)) continue;
 		if (await rootContainsGjcManifest(root.path)) {
 			filteredWarnings.push(`[claude-plugins] Skipping gajae-code plugin root (binding-only): ${root.path}`);
 			continue;
@@ -115,11 +119,14 @@ async function listNonGjcPluginRoots(
 // Skills
 // =============================================================================
 
-async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+export async function loadMarketplaceSkills(
+	ctx: LoadContext,
+	allowedLevels: ReadonlySet<"user" | "project"> = new Set(["user", "project"]),
+): Promise<LoadResult<Skill>> {
 	const items: Skill[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd, allowedLevels);
 	warnings.push(...rootWarnings);
 
 	const results = await Promise.all(
@@ -129,6 +136,7 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 				dir: skillsDir,
 				providerId: PROVIDER_ID,
 				level: root.scope,
+				requireDescription: true,
 			});
 			return { root, result, warning };
 		}),
@@ -371,7 +379,7 @@ registerProvider<Skill>(skillCapability.id, {
 	displayName: DISPLAY_NAME,
 	description: "Load skills from GJC marketplace plugins",
 	priority: PRIORITY,
-	load: loadSkills,
+	load: loadMarketplaceSkills,
 });
 
 registerProvider<SlashCommand>(slashCommandCapability.id, {