@gajae-code/coding-agent 0.8.1 → 0.8.2

package/src/gjc-runtime/team-runtime.ts

@@ -1896,16 +1896,39 @@ function readCurrentTmuxLeaderContext(tmuxCommand: string, env: NodeJS.ProcessEn
 	}
 	return { sessionName, windowIndex, leaderPaneId, target: `${sessionName}:${windowIndex}` };
 }
+type CommandPathResolver = (command: string) => string | null;
+
+function isBunVirtualPath(candidate: string | undefined): boolean {
+	const normalized = candidate?.trim().replace(/\\/g, "/");
+	return normalized === "/$bunfs" || normalized?.startsWith("/$bunfs/") === true;
+}
+
+function resolveFallbackGjcWorkerCommand(
+	platform: NodeJS.Platform,
+	execPath: string,
+	which: CommandPathResolver,
+): string {
+	const pathModule = platform === "win32" ? path.win32 : path;
+	const quote = platform === "win32" ? powershellQuote : shellQuote;
+	const executable = execPath.trim();
+	if (executable && !isBunVirtualPath(executable) && pathModule.isAbsolute(executable)) return quote(executable);
+	const gjcPath = which("gjc")?.trim();
+	if (gjcPath && !isBunVirtualPath(gjcPath)) return quote(gjcPath);
+	return "gjc";
+}
+
 export function resolveGjcWorkerCommand(
 	cwd = process.cwd(),
 	env: NodeJS.ProcessEnv = process.env,
 	platform: NodeJS.Platform = process.platform,
 	argv: string[] = process.argv,
 	execPath = process.execPath,
+	which: CommandPathResolver = Bun.which,
 ): string {
 	const explicit = env.GJC_TEAM_WORKER_COMMAND?.trim();
 	if (explicit) return explicit;
 	const entrypoint = argv[1];
+	if (isBunVirtualPath(entrypoint)) return resolveFallbackGjcWorkerCommand(platform, execPath, which);
 	if (!entrypoint) return "gjc";
 	const pathModule = platform === "win32" ? path.win32 : path;
 	const resolvedEntrypoint = pathModule.isAbsolute(entrypoint) ? entrypoint : pathModule.resolve(cwd, entrypoint);

package/src/gjc-runtime/ultragoal-runtime.ts

@@ -458,8 +458,8 @@ function latestRelevantLedgerEventId(
 	for (const event of [...ledger].reverse()) {
 		const eventId = ledgerEventId(event);
 		if (eventId && eventId === excludeEventId) continue;
-		const goalId = typeof event.goalId === "string" ? event.goalId : null;
-		if (!goalId || relevant.has(goalId)) return eventId;
+		const goalId = typeof event.goalId === "string" ? event.goalId.trim() : "";
+		if (goalId && relevant.has(goalId)) return eventId;
 	}
 	return null;
 }
@@ -1074,6 +1074,7 @@ interface UltragoalChangeSet extends JsonObject {
 	mergeBase?: string;
 	paths: UltragoalChangeSetPath[];
 	rawDiffStat?: string;
+	rawDiff?: string;
 	trusted: true;
 }
 
@@ -1086,11 +1087,16 @@ const MANDATORY_COMPUTER_CASE_IDS = [
 	"runaway-loop-halt",
 	"blast-radius",
 ] as const;
+const TOOLS_INDEX_PATH = "packages/coding-agent/src/tools/index.ts";
 
 function normalizeRepoPath(value: string): string {
 	return value.replaceAll("\\\\", "/").replace(/^\.\//, "");
 }
 
+function isToolsIndexPath(value: string): boolean {
+	return normalizeRepoPath(value) === TOOLS_INDEX_PATH;
+}
+
 function categorizeComputerChangePath(value: string): UltragoalChangeCategory {
 	const normalized = normalizeRepoPath(value);
 	if (normalized.startsWith("crates/pi-natives/src/computer/")) return "code";
@@ -1101,7 +1107,6 @@ function categorizeComputerChangePath(value: string): UltragoalChangeCategory {
 	)
 		return "tool";
 	if (
-		normalized === "packages/coding-agent/src/tools/index.ts" ||
 		normalized === "packages/coding-agent/src/tools/renderers.ts" ||
 		normalized === "packages/coding-agent/src/config/settings-schema.ts"
 	)
@@ -1119,18 +1124,44 @@ function categorizeComputerChangePath(value: string): UltragoalChangeCategory {
 function isComputerControlSurfaceCategory(category: UltragoalChangeCategory): boolean {
 	// The computer-use red-team suite is conditional, not universal (see the
 	// ultragoal SKILL): require it only when the change actually touches
-	// computer-control source — the computer tool (`tool`), its settings/registry
-	// wiring (`settings-registry`), or computer Rust (`code`). A bare regeneration
-	// of the SHARED native binding (`generated-binding`: packages/natives/native/
-	// index.{d.ts,js}) is NOT by itself a computer-use change: that file is
-	// generated from Rust, so any real computer-use behavior change must also
-	// touch one of the categories above and will still trigger the suite. Treating
-	// the regenerated aggregate binding as a computer surface forced the suite on
-	// unrelated features (e.g. notifications), which the SKILL explicitly warns
-	// against, so it is excluded here.
+	// computer-control source — the computer tool (`tool`), its behavior-bearing
+	// settings/renderer wiring (`settings-registry`), or computer Rust (`code`).
+	// A bare regeneration of the SHARED native binding (`generated-binding`:
+	// packages/natives/native/index.{d.ts,js}) is NOT by itself a computer-use
+	// change: that file is generated from Rust, so any real computer-use behavior
+	// change must also touch one of the categories above and will still trigger
+	// the suite. Treating aggregate binding or registration files as a computer
+	// surface forced the suite on unrelated changes, which the SKILL explicitly
+	// warns against, so they are excluded here.
 	return category === "code" || category === "tool" || category === "settings-registry";
 }
 
+function isComputerSpecificToolsIndexDiff(diff: string | undefined, targetPath: string): boolean {
+	if (!diff || !isToolsIndexPath(targetPath)) return false;
+	let inTargetFile = false;
+	for (const line of diff.split("\n")) {
+		if (line.startsWith("diff --git ")) {
+			const match = /^diff --git a\/(.+?) b\/(.+)$/.exec(line);
+			inTargetFile = !!match && (isToolsIndexPath(match[1]!) || isToolsIndexPath(match[2]!));
+			continue;
+		}
+		if (!inTargetFile || line.startsWith("+++") || line.startsWith("---")) continue;
+		if (!line.startsWith("+") && !line.startsWith("-")) continue;
+		const changedLine = line.slice(1);
+		if (
+			/\bComputerTool\b/.test(changedLine) ||
+			/\bisComputerCallable\b/.test(changedLine) ||
+			/\bisComputerLoadablePlatform\b/.test(changedLine) ||
+			/["']computer["']/.test(changedLine) ||
+			/["']\.\/computer["']/.test(changedLine) ||
+			/\bcomputer\s*:/.test(changedLine)
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
 function isComputerControlSurfaceChangePath(row: UltragoalChangeSetPath): boolean {
 	const category = row.category ?? categorizeComputerChangePath(row.path);
 	const oldCategory = row.oldPath ? categorizeComputerChangePath(row.oldPath) : category;
@@ -1139,7 +1170,13 @@ function isComputerControlSurfaceChangePath(row: UltragoalChangeSetPath): boolea
 
 function trustedChangeSetRequiresComputerSuite(changeSet: UltragoalChangeSet | undefined): boolean {
 	if (!changeSet?.trusted) return false;
-	return changeSet.paths.some(isComputerControlSurfaceChangePath);
+	return changeSet.paths.some(row => {
+		if (isComputerControlSurfaceChangePath(row)) return true;
+		return (
+			isComputerSpecificToolsIndexDiff(changeSet.rawDiff, row.path) ||
+			(row.oldPath ? isComputerSpecificToolsIndexDiff(changeSet.rawDiff, row.oldPath) : false)
+		);
+	});
 }
 
 function requiresComputerRedTeamSuite(executorQa: JsonObject, changeSet: UltragoalChangeSet | undefined): boolean {
@@ -3184,15 +3221,17 @@ function mergeChangeSetPaths(groups: UltragoalChangeSetPath[][]): UltragoalChang
 async function computeCheckpointChangeSet(cwd: string): Promise<UltragoalChangeSet | undefined> {
 	const inGit = await spawnText(["git", "rev-parse", "--is-inside-work-tree"], { cwd, timeoutMs: 3000 });
 	if (!inGit.ok || inGit.stdout.trim() !== "true") return undefined;
-	if (!(await Bun.file(path.join(cwd, ".git")).exists())) return undefined;
 	const baseRef = await resolveGitBase(cwd);
 	const base = baseRef;
 	const mergeBase = await spawnText(["git", "merge-base", "HEAD", baseRef], { cwd, timeoutMs: 3000 });
-	const [committed, unstaged, staged, stat] = await Promise.all([
+	const [committed, unstaged, staged, stat, committedDiff, unstagedDiff, stagedDiff] = await Promise.all([
 		spawnText(["git", "diff", "--name-status", `${base}...HEAD`], { cwd, timeoutMs: 5000 }),
 		spawnText(["git", "diff", "--name-status"], { cwd, timeoutMs: 5000 }),
 		spawnText(["git", "diff", "--cached", "--name-status"], { cwd, timeoutMs: 5000 }),
 		spawnText(["git", "diff", "--stat", `${base}...HEAD`], { cwd, timeoutMs: 5000 }),
+		spawnText(["git", "diff", `${base}...HEAD`], { cwd, timeoutMs: 5000 }),
+		spawnText(["git", "diff"], { cwd, timeoutMs: 5000 }),
+		spawnText(["git", "diff", "--cached"], { cwd, timeoutMs: 5000 }),
 	]);
 	if (!committed.ok && !unstaged.ok && !staged.ok) return undefined;
 	return {
@@ -3206,6 +3245,7 @@ async function computeCheckpointChangeSet(cwd: string): Promise<UltragoalChangeS
 			parseGitNameStatus(staged.stdout),
 		]),
 		rawDiffStat: stat.stdout,
+		rawDiff: [committedDiff.stdout, unstagedDiff.stdout, stagedDiff.stdout].filter(Boolean).join("\n"),
 		trusted: true,
 	};
 }
@@ -3236,6 +3276,7 @@ function changeSetFromReviewSource(source: JsonObject): UltragoalChangeSet | und
 			source: "review-pr",
 			paths: parseUnifiedDiffPaths(source.diff),
 			rawDiffStat: source.diff,
+			rawDiff: source.diff,
 			trusted: true,
 		};
 	const local = qualityGateObject(source.local);
@@ -3245,6 +3286,7 @@ function changeSetFromReviewSource(source: JsonObject): UltragoalChangeSet | und
 			source: "review-worktree",
 			paths: parseGitNameStatus(String(source.nameStatus ?? source.status ?? "")),
 			rawDiffStat: String(source.diffStat ?? ""),
+			rawDiff: String(source.diff ?? ""),
 			trusted: true,
 		};
 	if (kind === "branch" || kind === "pr-fallback")
@@ -3254,6 +3296,7 @@ function changeSetFromReviewSource(source: JsonObject): UltragoalChangeSet | und
 			headRef: "HEAD",
 			paths: parseGitNameStatus(String(source.nameStatus ?? "")),
 			rawDiffStat: String(source.diffStat ?? ""),
+			rawDiff: String(source.diff ?? ""),
 			trusted: true,
 		};
 	return undefined;
@@ -3261,25 +3304,36 @@ function changeSetFromReviewSource(source: JsonObject): UltragoalChangeSet | und
 
 async function localDiffSource(cwd: string, sourceKind: string, branch?: string): Promise<JsonObject> {
 	if (sourceKind === "worktree") {
-		const [status, diff, unstaged, staged] = await Promise.all([
+		const [status, diffStat, unstaged, staged, unstagedDiff, stagedDiff] = await Promise.all([
 			spawnText(["git", "status", "--short"], { cwd, timeoutMs: 5000 }),
 			spawnText(["git", "diff", "--stat"], { cwd, timeoutMs: 5000 }),
 			spawnText(["git", "diff", "--name-status"], { cwd, timeoutMs: 5000 }),
 			spawnText(["git", "diff", "--cached", "--name-status"], { cwd, timeoutMs: 5000 }),
+			spawnText(["git", "diff"], { cwd, timeoutMs: 5000 }),
+			spawnText(["git", "diff", "--cached"], { cwd, timeoutMs: 5000 }),
 		]);
 		return {
 			kind: "worktree",
 			status: status.stdout,
-			diffStat: diff.stdout,
+			diffStat: diffStat.stdout,
+			diff: [unstagedDiff.stdout, stagedDiff.stdout].filter(Boolean).join("\n"),
 			nameStatus: `${unstaged.stdout}\n${staged.stdout}`,
 		};
 	}
 	const base = await resolveGitBase(cwd, branch);
-	const [diff, nameStatus] = await Promise.all([
+	const [diffStat, nameStatus, diff] = await Promise.all([
 		spawnText(["git", "diff", "--stat", `${base}...HEAD`], { cwd, timeoutMs: 5000 }),
 		spawnText(["git", "diff", "--name-status", `${base}...HEAD`], { cwd, timeoutMs: 5000 }),
+		spawnText(["git", "diff", `${base}...HEAD`], { cwd, timeoutMs: 5000 }),
 	]);
-	return { kind: sourceKind, base, branch, diffStat: diff.stdout, nameStatus: nameStatus.stdout };
+	return {
+		kind: sourceKind,
+		base,
+		branch,
+		diffStat: diffStat.stdout,
+		diff: diff.stdout,
+		nameStatus: nameStatus.stdout,
+	};
 }
 
 async function resolveReviewSource(

package/src/hooks/native-skill-hook.ts

@@ -143,6 +143,34 @@ function readPromptText(payload: HookPayload): string {
 	return safeString(payload.prompt ?? payload.user_prompt ?? payload.userPrompt).trim();
 }
 
+const QUESTION_ONLY_ADVISORY_CONTEXT =
+	"Question-only prompt advisory: Treat bare '?' and unambiguous informational questions as answer-only/read-only; do not modify files, run commands, or execute workflow changes unless the user explicitly asks for action.";
+
+const QUESTION_EXPLICIT_ACTION_PATTERN =
+	/\b(add|apply|build|change|commit|create|delete|edit|execute|fix|implement|install|merge|modify|move|patch|refactor|remove|rename|replace|run|ship|start|stop|test|update|write)\b/i;
+const QUESTION_START_PATTERN =
+	/^(what|why|how|when|where|who|which|does|do|did|is|are|was|were|can|could|should|would)\b/i;
+
+function classifyQuestionOnlyPrompt(prompt: string): string | null {
+	const normalized = prompt.trim().replace(/\s+/g, " ");
+	if (!normalized) {
+		return null;
+	}
+	if (normalized === "?") {
+		return QUESTION_ONLY_ADVISORY_CONTEXT;
+	}
+	if (!normalized.endsWith("?")) {
+		return null;
+	}
+	if (QUESTION_EXPLICIT_ACTION_PATTERN.test(normalized)) {
+		return null;
+	}
+	if (!QUESTION_START_PATTERN.test(normalized)) {
+		return null;
+	}
+	return QUESTION_ONLY_ADVISORY_CONTEXT;
+}
+
 function readSessionId(payload: HookPayload): string | undefined {
 	return safeString(payload.session_id ?? payload.sessionId).trim() || undefined;
 }
@@ -221,6 +249,7 @@ export async function dispatchGjcNativeSkillHook(
 		const additionalContext = [
 			skillState ? buildSkillActivationAdditionalContext(skillState, effectiveSkillConfig) : activeUltragoalContext,
 			recoveryContext,
+			classifyQuestionOnlyPrompt(prompt),
 		]
 			.filter((value): value is string => Boolean(value))
 			.join(" ");