@gajae-code/coding-agent 0.12.4 → 0.12.6

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

@@ -1,4 +1,5 @@
 /** File-backed team task store, claims, leases, and completion evidence. */
+import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
@@ -324,15 +325,32 @@ async function writeJson(filePath: string, value: unknown): Promise<void> {
 }
 
 /**
- * Serializes mutable team facts across processes. Callers must not re-enter this
- * fence; use unlocked helpers when composing operations under one transaction.
+ * Serializes mutable team facts across processes. Nested operations inherit the
+ * outer filesystem lock and execute directly; independent callers queue locally
+ * before contending for the cross-process lock.
  */
+const teamMutationFenceTails = new Map<string, Promise<void>>();
+const activeTeamMutationFences = new AsyncLocalStorage<ReadonlySet<string>>();
+
 export async function withGjcTeamMutationFence<T>(dir: string, fn: () => Promise<T>): Promise<T> {
-	return withWorkflowStateLock(
-		path.join(dir, "operations", "team-mutation.json"),
-		fn,
-		writerOptions(path.join(dir, "operations", "team-mutation.json"), "state", "mutation-fence"),
-	);
+	const lockPath = path.join(dir, "operations", "team-mutation.json");
+	const active = activeTeamMutationFences.getStore();
+	if (active?.has(lockPath)) return await fn();
+	const previous = teamMutationFenceTails.get(lockPath) ?? Promise.resolve();
+	let releaseQueue!: () => void;
+	const queued = new Promise<void>(resolve => {
+		releaseQueue = resolve;
+	});
+	teamMutationFenceTails.set(lockPath, queued);
+	await previous;
+	try {
+		return await activeTeamMutationFences.run(new Set([...(active ?? []), lockPath]), () =>
+			withWorkflowStateLock(lockPath, fn, writerOptions(lockPath, "state", "mutation-fence")),
+		);
+	} finally {
+		releaseQueue();
+		if (teamMutationFenceTails.get(lockPath) === queued) teamMutationFenceTails.delete(lockPath);
+	}
 }
 function optionalString(value: unknown): string | undefined {
 	return typeof value === "string" && value.trim() ? value.trim() : undefined;

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

@@ -42,6 +42,7 @@ export interface GjcTeamWorkerRuntime {
 	workerDir(dir: string, worker: string): string;
 	readJson<T>(filePath: string): Promise<T | null>;
 	writeJson(filePath: string, value: unknown): Promise<void>;
+	withTaskMutation<T>(dir: string, fn: (capability: GjcTeamTaskMutationCapability) => Promise<T>): Promise<T>;
 	appendEvent(
 		dir: string,
 		event: { type: string; worker?: string; task_id?: string; message: string; data?: Record<string, unknown> },
@@ -368,6 +369,140 @@ export async function writeGjcWorkerStartupAck(
 	});
 	return ack;
 }
+export const GJC_TEAM_CONTINUATION_ACK_POLL_MS = 50;
+export function isValidGjcContinuationAck(
+	value: unknown,
+	reservation: Record<string, unknown>,
+	incident: string,
+	attempt: number,
+): value is Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const ack = value as Record<string, unknown>;
+	const keys = [
+		"schema_version",
+		"incident_hash",
+		"attempt",
+		"attempt_nonce",
+		"reservation_sha256",
+		"worker",
+		"pane_id",
+		"worker_incarnation",
+		"claim_token",
+		"acknowledged_at",
+	];
+	return (
+		Object.keys(ack).length === keys.length &&
+		Object.keys(ack).every(key => keys.includes(key)) &&
+		ack.schema_version === 1 &&
+		ack.incident_hash === incident &&
+		ack.attempt === attempt &&
+		ack.attempt_nonce === reservation.attempt_nonce &&
+		ack.reservation_sha256 === gjcContinuationReservationDigest(reservation) &&
+		ack.worker === reservation.worker &&
+		ack.pane_id === reservation.pane_id &&
+		ack.worker_incarnation === reservation.worker_incarnation &&
+		ack.claim_token === reservation.claim_token &&
+		typeof ack.acknowledged_at === "string" &&
+		Number.isFinite(Date.parse(ack.acknowledged_at))
+	);
+}
+
+export async function writeGjcWorkerContinuationAck(
+	runtime: GjcTeamWorkerRuntime,
+	teamName: string,
+	worker: string,
+	cwd: string,
+	env: NodeJS.ProcessEnv,
+	input: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+	const dir = await runtime.findTeamDir(teamName, cwd, env);
+	const inputKeys = ["team_name", "worker_id", "incident_hash", "attempt"];
+	if (
+		Object.keys(input).length !== inputKeys.length ||
+		Object.keys(input).some(key => !inputKeys.includes(key)) ||
+		input.team_name !== teamName ||
+		input.worker_id !== worker ||
+		typeof input.incident_hash !== "string" ||
+		!/^[0-9a-f]{24}$/.test(input.incident_hash) ||
+		(input.attempt !== 1 && input.attempt !== 2)
+	)
+		throw new Error("invalid_continuation_ack_reference");
+	const incident = input.incident_hash;
+	const attempt = input.attempt;
+	return runtime.withTaskMutation(dir, async () => {
+		const config = await runtime.readConfig(dir);
+		const teamWorker = runtime.findKnownWorker(config, worker);
+		const reservation = await readRuntimeJson<Record<string, unknown>>(
+			runtime,
+			path.join(runtime.workerDir(dir, worker), "continuations", incident, `attempt-0${attempt}.reservation.json`),
+		);
+		if (!reservation) throw new Error("missing_continuation_reservation");
+		const task = await readRuntimeJson<unknown>(
+			runtime,
+			path.join(dir, "tasks", `${String(reservation.task_id)}.json`),
+		);
+		const claim = await readRuntimeJson<unknown>(
+			runtime,
+			path.join(dir, "claims", `${String(reservation.task_id)}.json`),
+		);
+		if (
+			!isCanonicalPersistedGjcTeamTask(task, String(reservation.task_id)) ||
+			!isCanonicalPersistedGjcTeamTaskClaim(claim) ||
+			task.claim?.owner !== worker ||
+			task.claim?.token !== reservation.claim_token ||
+			claim.owner !== worker ||
+			claim.token !== reservation.claim_token
+		)
+			throw new Error("continuation_ack_claim_authority_changed");
+		const heartbeat = await readRuntimeJson<WorkerHeartbeatFile>(runtime, heartbeatPath(runtime, dir, worker));
+		if (
+			!heartbeat?.last_turn_at ||
+			!isValidGjcContinuationReservation(
+				reservation,
+				incident,
+				attempt,
+				config,
+				worker,
+				task,
+				claim,
+				heartbeat.last_turn_at,
+				teamWorker.pane_id ?? "",
+			)
+		)
+			throw new Error("invalid_continuation_reservation");
+		const lifecycle = await readWorkerLifecycleRecord(runtime, dir, teamWorker);
+		const incarnation = `${teamWorker.pane_id ?? ""}:${lifecycle.started_at ?? lifecycle.updated_at}`;
+		if (
+			reservation.worker !== worker ||
+			reservation.pane_id !== teamWorker.pane_id ||
+			reservation.pane_id !== lifecycle.pane_id ||
+			reservation.worker_incarnation !== incarnation
+		)
+			throw new Error("continuation_ack_binding_mismatch");
+		const ack = {
+			schema_version: 1,
+			incident_hash: incident,
+			attempt,
+			attempt_nonce: reservation.attempt_nonce,
+			reservation_sha256: gjcContinuationReservationDigest(reservation),
+			worker,
+			pane_id: reservation.pane_id,
+			worker_incarnation: reservation.worker_incarnation,
+			claim_token: reservation.claim_token,
+			acknowledged_at: runtime.now(),
+		};
+		await runtime.writeJson(
+			path.join(runtime.workerDir(dir, worker), "continuations", incident, `attempt-0${attempt}.ack.json`),
+			ack,
+		);
+		await runtime.appendEvent(dir, {
+			type: "worker_continuation_ack",
+			worker,
+			message: `Worker ${worker} acknowledged continuation`,
+		});
+		return ack;
+	});
+}
 
 export async function writeGjcShutdownRequest(
 	runtime: GjcTeamWorkerRuntime,
@@ -513,6 +648,21 @@ function isContinuationLifecycleEligible(lifecycle: GjcTeamWorkerLifecycle, stat
 export const GJC_TEAM_CONTINUATION_PROMPT =
 	"Continue only your current claimed GJC team task. Re-read current GJC team state; do not replay prior output; report status.";
 
+export function buildGjcContinuationPrompt(reservation: Record<string, unknown>): string {
+	const teamName = typeof reservation.team_name === "string" ? reservation.team_name : "";
+	const worker = typeof reservation.worker === "string" ? reservation.worker : "";
+	const incident = typeof reservation.incident_hash === "string" ? reservation.incident_hash : "";
+	const attempt = reservation.attempt === 1 || reservation.attempt === 2 ? reservation.attempt : 0;
+	if (!teamName || !worker || !incident || !attempt) throw new Error("invalid_continuation_reservation_reference");
+	const input = JSON.stringify({
+		team_name: teamName,
+		worker_id: worker,
+		incident_hash: incident,
+		attempt,
+	});
+	return `${GJC_TEAM_CONTINUATION_PROMPT} ACK now: gjc team api worker-continuation-ack --input '${input}' --json.`;
+}
+
 function canonicalJson(value: unknown): string {
 	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
 	if (typeof value === "object" && value !== null) {
@@ -542,7 +692,9 @@ const reservationKeys = new Set([
 	"heartbeat_at",
 	"pane_id",
 	"tmux_target",
+	"worker_incarnation",
 	"attempt",
+	"attempt_nonce",
 	"reserved_at",
 	"hold_until",
 	"prompt_version",
@@ -584,10 +736,14 @@ export function isValidGjcContinuationReservation(
 		record.heartbeat_at === heartbeatAt &&
 		record.pane_id === paneId &&
 		record.tmux_target === config.tmux_target &&
+		typeof record.worker_incarnation === "string" &&
+		record.worker_incarnation.length > 0 &&
 		record.attempt === attempt &&
+		typeof record.attempt_nonce === "string" &&
+		/^[0-9a-f-]{36}$/i.test(record.attempt_nonce) &&
 		record.prompt_version === 1 &&
 		record.dispatch_protocol === "tmux_command_sequence_v1" &&
-		record.prompt_sha256 === createHash("sha256").update(GJC_TEAM_CONTINUATION_PROMPT).digest("hex") &&
+		record.prompt_sha256 === createHash("sha256").update(buildGjcContinuationPrompt(record)).digest("hex") &&
 		Number.isFinite(reservedAt) &&
 		Number.isFinite(holdUntil) &&
 		Number.isFinite(leaseUntil) &&
@@ -683,6 +839,10 @@ export function isValidGjcContinuationOutcome(
 			exit === undefined &&
 			error === undefined &&
 			hasExactKeys(baseKeys)) ||
+		(outcome.reason === "tmux_exit_zero_unacknowledged" &&
+			exit === 0 &&
+			error === undefined &&
+			hasExactKeys([...baseKeys, "tmux_exit_code"])) ||
 		(outcome.reason === "tmux_nonzero_exit" &&
 			typeof exit === "number" &&
 			Number.isInteger(exit) &&

package/src/gjc-runtime/tmux-common.ts

@@ -1,6 +1,19 @@
 import type { ResolvedTmuxBinary } from "./psmux-detect";
 import { resolveGjcTmuxBinary } from "./psmux-detect";
 
+export {
+	assertGjcTmuxMutationAuthoritySync,
+	bindGjcTmuxProviderAuthority,
+	buildTmuxProviderCommand,
+	hasGjcTmuxProviderAuthoritySync,
+	type ProviderAuthority,
+	type ProviderContext,
+	persistGjcTmuxProviderAuthoritySync,
+	readGjcTmuxProviderAuthoritySync,
+	resolveGjcTmuxProviderContext,
+	type TmuxProviderKind,
+} from "./tmux-provider-context";
+
 export const GJC_DEFAULT_TMUX_SESSION = "gajae_code";
 export const GJC_TMUX_SESSION_PREFIX = `${GJC_DEFAULT_TMUX_SESSION}_`;
 export const GJC_TMUX_COMMAND_ENV = "GJC_TMUX_COMMAND";
@@ -112,10 +125,9 @@ export function buildGjcTmuxUntaggedSessionHint(tmuxCommand: string): string {
 	return (
 		`the active multiplexer "${tmuxCommand}" lists this session but did not return GJC's ${GJC_TMUX_PROFILE_OPTION} ownership tag; ` +
 		"GJC-managed sessions and `gjc team` require a tmux provider that round-trips tmux user options. " +
-		"For psmux on Windows, cwd/start-directory flags such as `-c` do not isolate the server namespace; psmux uses the tmux-compatible global `-L <namespace>` flag for that. " +
-		"GJC_TMUX_COMMAND and GJC_TEAM_TMUX_COMMAND are binary overrides, not shell command lines, so `psmux -L name` is not a supported value. " +
-		"Alternative multiplexers such as psmux on Windows do not reliably persist user options yet, so the Windows-native psmux path is not fully supported; " +
-		"use real tmux for GJC-managed session and team flows."
+		"On Windows psmux, GJC persists a ProviderAuthority that binds the exact executable identity and an isolated `-L <namespace>` server namespace for the owner generation. " +
+		"Recover through GJC so it reuses that persisted authority; do not retry against ambient tmux/psmux or a raw `-L` namespace. " +
+		"GJC_TMUX_COMMAND and GJC_TEAM_TMUX_COMMAND are binary overrides, not shell command lines."
 	);
 }
 

package/src/gjc-runtime/tmux-gc.ts

@@ -5,11 +5,17 @@
  */
 
 import * as fs from "node:fs";
+import * as path from "node:path";
 
 import { GitCommandError, worktree } from "../utils/git";
 import type { GcCollectResult, GcContext, GcPruneOutcome, GcRecord, GcStoreAdapter } from "./gc-runtime";
-import { readTerminalRuntimeStateMarker } from "./session-state-sidecar";
-import { GJC_TMUX_PROFILE_VALUE, GJC_TMUX_SESSION_PREFIX } from "./tmux-common";
+import {
+	GJC_COORDINATOR_SESSION_ID_ENV,
+	GJC_TMUX_OWNER_GENERATION_ENV,
+	GJC_TMUX_OWNER_STATE_DIR_ENV,
+	readTerminalRuntimeStateMarker,
+} from "./session-state-sidecar";
+import { GJC_TMUX_PROFILE_VALUE, GJC_TMUX_SESSION_PREFIX, hasGjcTmuxProviderAuthoritySync } from "./tmux-common";
 import {
 	type GjcTmuxSessionStatus,
 	type GjcTmuxSessionsForGc,
@@ -29,6 +35,9 @@ type CollectedTmuxIdentity = {
 	sessionStateFile: string;
 	project: string;
 	createdAt: string;
+	providerKind: "native-tmux" | "windows-psmux";
+	psmuxIncarnation?: string;
+	providerCommand?: string;
 };
 
 const collectedIdentities = new WeakMap<GcRecord, CollectedTmuxIdentity>();
@@ -43,6 +52,15 @@ function collectedIdentity(session: GjcTmuxSessionStatus): CollectedTmuxIdentity
 		!session.createdAt
 	)
 		return undefined;
+	const stateDir = path.dirname(session.sessionStateFile);
+	const providerKind = hasGjcTmuxProviderAuthoritySync({
+		stateDir,
+		sessionId: session.sessionId,
+		generation: session.ownerGeneration,
+	})
+		? "windows-psmux"
+		: "native-tmux";
+	if (providerKind === "windows-psmux" && !session.psmuxIncarnation) return undefined;
 	return {
 		nativeSessionId: session.nativeSessionId,
 		ownerGeneration: session.ownerGeneration,
@@ -50,6 +68,19 @@ function collectedIdentity(session: GjcTmuxSessionStatus): CollectedTmuxIdentity
 		sessionStateFile: session.sessionStateFile,
 		project: session.project,
 		createdAt: session.createdAt,
+		psmuxIncarnation: session.psmuxIncarnation,
+		providerKind,
+		providerCommand: session.providerAuthority?.command,
+	};
+}
+function authorityEnv(identity: CollectedTmuxIdentity, env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+	if (identity.providerKind !== "windows-psmux") return env;
+	return {
+		...env,
+		GJC_TMUX_COMMAND: identity.providerCommand,
+		[GJC_COORDINATOR_SESSION_ID_ENV]: identity.sessionId,
+		[GJC_TMUX_OWNER_GENERATION_ENV]: identity.ownerGeneration,
+		[GJC_TMUX_OWNER_STATE_DIR_ENV]: path.dirname(identity.sessionStateFile),
 	};
 }
 
@@ -204,14 +235,15 @@ async function revalidateRemovable(
 	identity: CollectedTmuxIdentity,
 	env: NodeJS.ProcessEnv,
 ): Promise<boolean> {
-	const tags = readTmuxSessionTagsForGc(record.id, env);
+	const tags = readTmuxSessionTagsForGc(record.id, authorityEnv(identity, env));
 	if (
 		tags.nativeSessionId !== identity.nativeSessionId ||
 		tags.ownerGeneration !== identity.ownerGeneration ||
 		tags.sessionId !== identity.sessionId ||
 		tags.sessionStateFile !== identity.sessionStateFile ||
 		tags.project !== identity.project ||
-		tags.createdAt !== identity.createdAt
+		tags.createdAt !== identity.createdAt ||
+		tags.psmuxIncarnation !== identity.psmuxIncarnation
 	)
 		return false;
 	if (tags.attached || (tags.panePids?.length ?? 0) > 0) return false;
@@ -273,7 +305,7 @@ export const tmuxSessionsGcAdapter: GcStoreAdapter = {
 			if (!identity || !(await revalidateRemovable(record, identity, ctx.env))) {
 				return { removed: false, skipped: TOCTOU_SKIP };
 			}
-			removeGjcTmuxSession(record.id, ctx.env, identity);
+			removeGjcTmuxSession(record.id, authorityEnv(identity, ctx.env), identity);
 			return { removed: true };
 		} catch (error) {
 			return { removed: false, error: error instanceof Error ? error.message : String(error) };

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

@@ -2182,6 +2182,8 @@ async function fsyncDirectory(directoryPath: string): Promise<void> {
 	const directory = await fs.open(directoryPath, "r");
 	try {
 		await directory.sync();
+	} catch (error) {
+		if (process.platform !== "win32" || (error as NodeJS.ErrnoException).code !== "EPERM") throw error;
 	} finally {
 		await directory.close();
 	}