@gajae-code/coding-agent 0.13.3 → 0.14.0

package/src/gjc-runtime/state-writer.ts

@@ -102,11 +102,23 @@ export type GuardedWriteResult =
 	| { path: string; written: true; revision: number; stamped: unknown }
 	| { path: string; written: false; reason: "stale-skip"; revision: number };
 
+export interface GuardedStateWriteReceipt {
+	path: string;
+	revision: number;
+	stamped: unknown;
+}
+
+export function guardedStateWriteReceipt(result: GuardedWriteResult): GuardedStateWriteReceipt | undefined {
+	return result.written ? { path: result.path, revision: result.revision, stamped: result.stamped } : undefined;
+}
+
 export interface StateWriterOptions {
 	cwd?: string;
 	receipt?: StateWriterReceiptContext;
 	audit?: StateWriterAuditContext;
 	sourceRevision?: number;
+	/** Advance a cache source revision under the target lock when the value carries none. */
+	advanceSourceRevision?: boolean;
 	/**
 	 * Cross-process lock tuning for read-modify-write paths that route through
 	 * `withWorkflowStateLock` / `updateJsonAtomic`. Omit for the hardened
@@ -442,6 +454,12 @@ function stampStateRevision(value: unknown, stateRevision: number, sourceRevisio
 		state_revision: stateRevision,
 	};
 }
+export function matchesGuardedStateWriteReceipt(current: unknown, receipt: GuardedStateWriteReceipt): boolean {
+	return (
+		persistedStateRevision(current) === receipt.revision &&
+		JSON.stringify(current) === JSON.stringify(receipt.stamped)
+	);
+}
 
 function withWorkflowReceipt(value: unknown, receipt: WorkflowStateReceipt | undefined): unknown {
 	if (!receipt || !value || typeof value !== "object" || Array.isArray(value)) return value;
@@ -531,8 +549,10 @@ async function writeGuardedResolvedJsonAtomic(
 				return { path: filePath, written: true, revision: currentRevision + 1, stamped: next };
 			}
 
+			const valueSourceRevision = isPlainObject(value) ? persistedSourceRevision(value) : 0;
 			const incomingSourceRevision =
-				options.sourceRevision ?? (isPlainObject(value) ? persistedStateRevision(value) : 0);
+				options.sourceRevision ??
+				(valueSourceRevision || (options.advanceSourceRevision ? persistedSourceRevision(current) + 1 : 0));
 			if (current !== undefined && incomingSourceRevision <= persistedSourceRevision(current)) {
 				return { path: filePath, written: false, reason: "stale-skip", revision: currentRevision };
 			}
@@ -960,12 +980,18 @@ export async function deleteIfOwned(
 	const options = typeof predicateOrOptions === "function" ? undefined : predicateOrOptions;
 	const predicate = typeof predicateOrOptions === "function" ? predicateOrOptions : predicateOrOptions?.predicate;
 	const filePath = resolveGjcTarget(targetPath, cwdForOptions(options));
-	const current = await readJsonIfPresent(filePath);
-	if (current === undefined) return { path: filePath, deleted: false };
-	if (predicate && !(await predicate(current))) return { path: filePath, deleted: false };
-	const deleted = await atomicRemove(filePath);
-	if (deleted) await maybeAudit(filePath, options);
-	return { path: filePath, deleted };
+	return lockResolvedWorkflowTarget(
+		filePath,
+		async () => {
+			const current = await readJsonIfPresent(filePath);
+			if (current === undefined) return { path: filePath, deleted: false };
+			if (predicate && !(await predicate(current))) return { path: filePath, deleted: false };
+			const deleted = await atomicRemove(filePath);
+			if (deleted) await maybeAudit(filePath, options);
+			return { path: filePath, deleted };
+		},
+		options?.lock,
+	);
 }
 
 export async function removeFileAudited(targetPath: string, options?: StateWriterOptions): Promise<DeleteResult> {
@@ -987,20 +1013,19 @@ export async function writeActiveEntry(
 	skill: string,
 	entry: SkillActiveEntry,
 	options?: StateWriterOptions,
-): Promise<string> {
+): Promise<GuardedWriteResult> {
 	const filePath = activeEntryPath(path.resolve(cwd), sessionScope, skill);
-	await writeGuardedResolvedJsonAtomic(
+	const result = await writeGuardedResolvedJsonAtomic(
 		filePath,
 		{ ...entry, skill },
 		{
 			...options,
 			policy: "cache",
-			sourceRevision:
-				persistedSourceRevision(entry) || persistedSourceRevision(await readJsonIfPresent(filePath)) + 1,
+			advanceSourceRevision: true,
 		},
 	);
 	invalidateActiveStateCacheForScope(cwd, sessionScope);
-	return filePath;
+	return result;
 }
 
 export async function removeActiveEntry(
@@ -1082,9 +1107,9 @@ export async function mergeActiveState(
 	entry: SkillActiveEntry,
 	options?: StateWriterOptions,
 ): Promise<ActiveEntryWriteResult> {
-	const entryPath = await writeActiveEntry(cwd, sessionScope, skill, entry, options);
+	const entryWrite = await writeActiveEntry(cwd, sessionScope, skill, entry, options);
 	const snapshotPath = await rebuildActiveSnapshot(cwd, sessionScope, options);
-	return { entryPath, snapshotPath };
+	return { entryPath: entryWrite.path, snapshotPath };
 }
 
 export async function writeArtifact(

package/src/gjc-runtime/tmux-owner-isolation.ts

@@ -1503,15 +1503,16 @@ const liveOwnerTerminalObservations = new Map<string, Promise<OwnerVerdict>>();
 export async function observeOwnerTerminal(request: ObserveTerminalRequest): Promise<OwnerVerdict> {
 	if (!isObserveTerminalRequest(request)) throw new Error("terminal_observation_invalid");
 	const paths = lifecyclePaths(request.state_dir, request.session_id, request.owner_generation);
-	const existing = liveOwnerTerminalObservations.get(paths.root);
+	const observationKey = JSON.stringify([paths.verdictFile, request.socket_key]);
+	const existing = liveOwnerTerminalObservations.get(observationKey);
 	if (existing) return existing;
 	const observation = observeOwnerTerminalExclusive(request);
-	liveOwnerTerminalObservations.set(paths.root, observation);
+	liveOwnerTerminalObservations.set(observationKey, observation);
 	try {
 		return await observation;
 	} finally {
-		if (liveOwnerTerminalObservations.get(paths.root) === observation)
-			liveOwnerTerminalObservations.delete(paths.root);
+		if (liveOwnerTerminalObservations.get(observationKey) === observation)
+			liveOwnerTerminalObservations.delete(observationKey);
 	}
 }
 

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

@@ -816,6 +816,8 @@ async function consumeUltragoalNudge(input: {
 	surface: UltragoalNudgeSurface;
 	currentGoal?: CurrentGoalLike | null;
 	sessionId?: string | null;
+	/** The session's effective agent directory (see resolveWorkflowSetting). */
+	agentDir?: string;
 }): Promise<{ nudged: true; message: string } | { nudged: false }> {
 	const sessionId = input.sessionId?.trim() || (await ultragoalReadPaths(input.cwd)).sessionId;
 	if (!sessionId) return { nudged: false };
@@ -823,7 +825,7 @@ async function consumeUltragoalNudge(input: {
 	if (!plan) return { nudged: false };
 	const target = selectUltragoalNudgeTarget(plan, { currentGoalObjective: input.currentGoal?.objective });
 	if (!target) return { nudged: false };
-	const { budget } = await resolveUltragoalNudgeBudget(input.cwd);
+	const { budget } = await resolveUltragoalNudgeBudget(input.cwd, input.agentDir);
 	const outcome = await recordUltragoalNudgeIfBudgetRemaining({
 		cwd: input.cwd,
 		sessionId,
@@ -855,15 +857,17 @@ async function consumeUltragoalNudge(input: {
 export async function consumeUltragoalAskNudge(
 	cwd: string,
 	sessionId?: string | null,
+	agentDir?: string,
 ): Promise<{ nudged: true; message: string } | { nudged: false }> {
 	if (!cwd) return { nudged: false };
-	return consumeUltragoalNudge({ cwd, surface: "ask", sessionId });
+	return consumeUltragoalNudge({ cwd, surface: "ask", sessionId, agentDir });
 }
 
 export async function assertCanCompleteCurrentGoal(input: {
 	cwd: string;
 	currentGoal?: CurrentGoalLike | null;
 	sessionId?: string | null;
+	agentDir?: string;
 }): Promise<void> {
 	if (!input.cwd) return;
 	const diagnostic = await verifyUltragoalDurableCompletionState(input);
@@ -871,6 +875,7 @@ export async function assertCanCompleteCurrentGoal(input: {
 	const nudge = await consumeUltragoalNudge({
 		cwd: input.cwd,
 		surface: "premature_complete",
+		agentDir: input.agentDir,
 		currentGoal: input.currentGoal,
 		sessionId: input.sessionId,
 	});
@@ -969,9 +974,9 @@ export async function isUltragoalPauseBlocked(cwd: string): Promise<UltragoalPau
 	};
 }
 
-export async function assertUltragoalPauseAllowed(cwd: string): Promise<void> {
+export async function assertUltragoalPauseAllowed(cwd: string, agentDir?: string): Promise<void> {
 	if (cwd) {
-		const nudge = await consumeUltragoalNudge({ cwd, surface: "pause" });
+		const nudge = await consumeUltragoalNudge({ cwd, surface: "pause", agentDir });
 		if (nudge.nudged) throw new Error(nudge.message);
 	}
 	const diagnostic = await isUltragoalPauseBlocked(cwd);
@@ -996,6 +1001,7 @@ export async function assertUltragoalDropAllowed(input: {
 	cwd: string;
 	currentGoal?: CurrentGoalLike | null;
 	sessionId?: string | null;
+	agentDir?: string;
 }): Promise<void> {
 	if (!input.cwd) return;
 	let paths: UltragoalPaths;
@@ -1041,6 +1047,7 @@ export async function assertUltragoalDropAllowed(input: {
 	const nudge = await consumeUltragoalNudge({
 		cwd: input.cwd,
 		surface: "drop",
+		agentDir: input.agentDir,
 		currentGoal: input.currentGoal,
 		sessionId,
 	});

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

@@ -1,7 +1,6 @@
 import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { getConfigRootDir } from "@gajae-code/utils";
 import type { WorkflowHudSummary } from "../skill-state/active-state";
 import { buildUltragoalHudSummary as buildWorkflowUltragoalHudSummary } from "../skill-state/workflow-hud";
 import { renderCliWriteReceipt } from "./cli-write-receipt";
@@ -46,6 +45,7 @@ export {
 	terminalCriticGateOverridden,
 } from "./ultragoal-receipt-freshness";
 
+import { isSettingsInitialized, Settings } from "../config/settings";
 import { gjcRoot, sessionUltragoalDir } from "./session-layout";
 import {
 	resolveGjcSessionForRead,
@@ -62,6 +62,7 @@ import {
 	writeArtifact,
 	writeGuardedJsonAtomic,
 } from "./state-writer";
+import { resolveWorkflowSetting } from "./workflow-settings";
 
 export {
 	captureUltragoalRecoverySnapshot,
@@ -387,39 +388,29 @@ function parseNudgeBudgetValue(value: unknown): number | null {
 	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0 ? value : null;
 }
 
-async function readSettingsNudgeBudget(settingsPath: string): Promise<number | null> {
-	try {
-		const raw = await Bun.file(settingsPath).text();
-		const parsed = JSON.parse(raw) as Record<string, unknown>;
-		// Support both the flat dotted key and a nested gjc.ultragoal.nudgeBudget shape.
-		const flat = parseNudgeBudgetValue(parsed["gjc.ultragoal.nudgeBudget"]);
-		if (flat !== null) return flat;
-		const gjc = parsed.gjc;
-		if (gjc && typeof gjc === "object") {
-			const ultragoal = (gjc as Record<string, unknown>).ultragoal;
-			if (ultragoal && typeof ultragoal === "object") {
-				return parseNudgeBudgetValue((ultragoal as Record<string, unknown>).nudgeBudget);
-			}
-		}
-		return null;
-	} catch {
-		return null;
-	}
-}
-
 /**
- * Resolve the per-story nudge budget. Project `./.gjc/settings.json` overrides the
- * user settings (`$GJC_CONFIG_DIR/settings.json` or `~/.gjc/settings.json`), else the
- * default. Mirrors the `gjc.deepInterview.ambiguityThreshold` user+project precedence.
+ * Resolve the per-story nudge budget through the shared five-layer resolver.
+ * Ultragoal stays tolerant: an invalid optional settings file continues to the
+ * next layer and finally to the built-in default (10).
  */
-export async function resolveUltragoalNudgeBudget(cwd: string): Promise<{ budget: number; source: string }> {
-	const projectPath = path.join(gjcRoot(cwd), "settings.json");
-	const project = await readSettingsNudgeBudget(projectPath);
-	if (project !== null) return { budget: project, source: projectPath };
-	const userPath = path.join(getConfigRootDir(), "settings.json");
-	const user = await readSettingsNudgeBudget(userPath);
-	if (user !== null) return { budget: user, source: userPath };
-	return { budget: DEFAULT_ULTRAGOAL_NUDGE_BUDGET, source: "default" };
+export async function resolveUltragoalNudgeBudget(
+	cwd: string,
+	agentDir?: string,
+): Promise<{ budget: number; source: string }> {
+	const resolution = await resolveWorkflowSetting(cwd, "gjc.ultragoal.nudgeBudget", {
+		defaultValue: DEFAULT_ULTRAGOAL_NUDGE_BUDGET,
+		parse: value => {
+			const parsed = parseNudgeBudgetValue(value);
+			return parsed === null
+				? { kind: "invalid", reason: "expected gjc.ultragoal.nudgeBudget to be a non-negative integer" }
+				: { kind: "valid", value: parsed };
+		},
+		// The session's effective agent profile: an SDK session created with
+		// `createAgentSession({ agentDir })` resolves against that directory
+		// instead of the process-global default.
+		agentDir: agentDir ?? (isSettingsInitialized() ? Settings.instance.getAgentDir() : undefined),
+	});
+	return { budget: resolution.value, source: resolution.source };
 }
 
 /**
@@ -1024,7 +1015,11 @@ function emptyCounts(): Record<UltragoalGoalStatus, number> {
 	};
 }
 
-export async function getUltragoalStatus(cwd: string, sessionId?: string | null): Promise<UltragoalStatusSummary> {
+export async function getUltragoalStatus(
+	cwd: string,
+	sessionId?: string | null,
+	agentDir?: string,
+): Promise<UltragoalStatusSummary> {
 	const resolvedSessionId =
 		sessionId?.trim() ||
 		(await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID })).gjcSessionId;
@@ -1043,7 +1038,7 @@ export async function getUltragoalStatus(cwd: string, sessionId?: string | null)
 	const nudgeTarget = selectUltragoalNudgeTarget(plan, { currentGoalObjective: currentGoal?.objective });
 	let nudgeFields: Partial<UltragoalStatusSummary> = {};
 	if (nudgeTarget) {
-		const { budget } = await resolveUltragoalNudgeBudget(cwd);
+		const { budget } = await resolveUltragoalNudgeBudget(cwd, agentDir);
 		const ledger = await readUltragoalLedger(cwd, resolvedSessionId);
 		const nudgeCount = countUltragoalNudges(ledger, nudgeTarget.goalId);
 		nudgeFields = {
@@ -5072,7 +5067,11 @@ async function executeUltragoalSteeringCommand(args: readonly string[], cwd: str
 	}
 }
 
-async function dispatchUltragoalCommand(args: string[], cwd: string): Promise<UltragoalCommandResult> {
+async function dispatchUltragoalCommand(
+	args: string[],
+	cwd: string,
+	agentDir?: string,
+): Promise<UltragoalCommandResult> {
 	// Help must not require a resolvable session; render it before session resolution.
 	const help = renderUltragoalHelp(args);
 	if (help) return { status: 0, stdout: help };
@@ -5090,7 +5089,7 @@ async function dispatchUltragoalCommand(args: string[], cwd: string): Promise<Ul
 		const json = hasFlag(args, "--json");
 		switch (command) {
 			case "status":
-				return { status: 0, stdout: renderStatus(await getUltragoalStatus(cwd, sessionId), json) };
+				return { status: 0, stdout: renderStatus(await getUltragoalStatus(cwd, sessionId, agentDir), json) };
 			case "create":
 			case "create-goals": {
 				const mode = flagValue(args, "--gjc-goal-mode") === "per-story" ? "per-story" : "aggregate";
@@ -5321,10 +5320,10 @@ const RECONCILE_COMMANDS = new Set([
  * therefore a read PLUS a derived repair; it never mutates goals.json/ledger.jsonl
  * beyond that reconcile-failure audit event.
  */
-async function reconcileUltragoalState(cwd: string): Promise<void> {
+async function reconcileUltragoalState(cwd: string, agentDir?: string): Promise<void> {
 	const sessionId = currentUltragoalSessionId(cwd);
 	try {
-		const summary = await getUltragoalStatus(cwd, sessionId);
+		const summary = await getUltragoalStatus(cwd, sessionId, agentDir);
 		const status = summary.status;
 		const active = summary.exists && status !== "complete";
 		const payload: Record<string, unknown> = {
@@ -5397,12 +5396,16 @@ async function reconcileUltragoalState(cwd: string): Promise<void> {
 	}
 }
 
-export async function runNativeUltragoalCommand(args: string[], cwd = process.cwd()): Promise<UltragoalCommandResult> {
+export async function runNativeUltragoalCommand(
+	args: string[],
+	cwd = process.cwd(),
+	options: { agentDir?: string } = {},
+): Promise<UltragoalCommandResult> {
 	const command = commandName(args);
-	const result = await dispatchUltragoalCommand(args, cwd);
+	const result = await dispatchUltragoalCommand(args, cwd, options.agentDir);
 	const isHelp = args.some(isHelpArg) || args[0] === "help";
 	if (!isHelp && result.status === 0 && RECONCILE_COMMANDS.has(command)) {
-		await reconcileUltragoalState(cwd);
+		await reconcileUltragoalState(cwd, options.agentDir);
 	}
 	return result;
 }