@gajae-code/coding-agent 0.8.1 → 0.9.0

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

@@ -204,6 +204,7 @@ export type GjcTeamNotificationDeliveryState =
 	| "acknowledged";
 
 export type GjcTeamPaneAttemptResult = "sent" | "queued" | "deferred" | "failed";
+export type GjcTeamMailboxDeliveryTransportKind = "notifications_sdk" | "pane";
 
 export interface GjcTeamNotification {
 	id: string;
@@ -220,6 +221,36 @@ export interface GjcTeamNotification {
 	updated_at: string;
 	replay_count: number;
 }
+export interface GjcTeamMailboxDeliveryInput {
+	team_name: string;
+	state_dir: string;
+	config: GjcTeamConfig;
+	notification: GjcTeamNotification;
+	message: GjcTeamMailboxMessage;
+	cwd: string;
+	env: NodeJS.ProcessEnv;
+}
+export type GjcTeamMailboxDeliveryResult =
+	| { transport: "notifications_sdk"; state: GjcTeamNotificationDeliveryState; reason?: string }
+	| { transport: "pane"; state: GjcTeamPaneAttemptResult; reason?: string };
+export interface GjcTeamMailboxDeliveryTransport {
+	deliverMailboxMessage(input: GjcTeamMailboxDeliveryInput): Promise<GjcTeamMailboxDeliveryResult | null>;
+}
+
+let gjcTeamMailboxDeliveryTransport: GjcTeamMailboxDeliveryTransport | undefined;
+
+export function setGjcTeamMailboxDeliveryTransport(transport: GjcTeamMailboxDeliveryTransport | undefined): () => void {
+	const previous = gjcTeamMailboxDeliveryTransport;
+	gjcTeamMailboxDeliveryTransport = transport;
+	return () => {
+		gjcTeamMailboxDeliveryTransport = previous;
+	};
+}
+export function setGjcTeamMailboxDeliveryTransportForTest(
+	transport: GjcTeamMailboxDeliveryTransport | undefined,
+): () => void {
+	return setGjcTeamMailboxDeliveryTransport(transport);
+}
 
 export interface GjcTeamNotificationSummary {
 	total: number;
@@ -256,6 +287,7 @@ export interface GjcTeamStartOptions {
 	cwd?: string;
 	env?: NodeJS.ProcessEnv;
 	dryRun?: boolean;
+	mailboxDeliveryTransport?: GjcTeamMailboxDeliveryTransport;
 }
 
 export interface GjcTeamApiClaimResult {
@@ -1056,6 +1088,22 @@ async function readConfig(dir: string): Promise<GjcTeamConfig> {
 		worker_cli_plan: config.worker_cli_plan ?? Array.from({ length: config.worker_count }, () => "gjc"),
 	};
 }
+const WORKER_INTEGRATION_CONFIG_CACHE_TTL_MS = 100;
+type WorkerIntegrationConfigCacheEntry = { checkedAt: number; mtimeMs: number; config: GjcTeamConfig };
+const workerIntegrationConfigCache = new Map<string, WorkerIntegrationConfigCacheEntry>();
+
+async function readConfigForWorkerIntegration(dir: string): Promise<GjcTeamConfig> {
+	const configPath = path.join(dir, "config.json");
+	const nowMs = Date.now();
+	const stat = await fs.stat(configPath);
+	const cached = workerIntegrationConfigCache.get(configPath);
+	if (cached && cached.mtimeMs === stat.mtimeMs && nowMs - cached.checkedAt <= WORKER_INTEGRATION_CONFIG_CACHE_TTL_MS)
+		return cached.config;
+	const config = await readConfig(dir);
+	workerIntegrationConfigCache.set(configPath, { checkedAt: nowMs, mtimeMs: stat.mtimeMs, config });
+
+	return config;
+}
 async function readPhase(dir: string): Promise<GjcTeamPhase> {
 	const phase = await readJsonFile<{ current_phase?: GjcTeamPhase }>(path.join(dir, "phase.json"));
 	return phase?.current_phase ?? "running";
@@ -1704,6 +1752,23 @@ function runGitResult(cwd: string, args: string[]): GitResult {
 		stderr: result.stderr.toString().trim(),
 	};
 }
+async function runGitResultAsync(cwd: string, args: string[]): Promise<GitResult> {
+	const result = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "pipe" });
+	const [exitCode, stdout, stderr] = await Promise.all([
+		result.exited,
+		new Response(result.stdout).text(),
+		new Response(result.stderr).text(),
+	]);
+	return {
+		ok: exitCode === 0,
+		stdout: stdout.trim(),
+		stderr: stderr.trim(),
+	};
+}
+async function tryRunGitAsync(cwd: string, args: string[]): Promise<string | null> {
+	const result = await runGitResultAsync(cwd, args);
+	return result.ok ? result.stdout : null;
+}
 function runGit(cwd: string, args: string[]): string {
 	const result = runGitResult(cwd, args);
 	if (result.ok) return result.stdout;
@@ -1896,16 +1961,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);
@@ -2295,6 +2383,9 @@ async function appendCommitHygieneEntries(config: GjcTeamConfig, entries: GjcTea
 function resolveHead(cwd: string): string | null {
 	return tryRunGit(cwd, ["rev-parse", "HEAD"]);
 }
+async function resolveHeadAsync(cwd: string): Promise<string | null> {
+	return tryRunGitAsync(cwd, ["rev-parse", "HEAD"]);
+}
 function isAncestor(cwd: string, ancestor: string, descendant: string): boolean {
 	return runGitResult(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]).ok;
 }
@@ -2314,6 +2405,14 @@ function listConflictFiles(cwd: string): string[] {
 		.map(line => line.trim())
 		.filter(Boolean);
 }
+async function listConflictFilesAsync(cwd: string): Promise<string[]> {
+	const result = await runGitResultAsync(cwd, ["diff", "--name-only", "--diff-filter=U"]);
+	if (!result.ok || !result.stdout) return [];
+	return result.stdout
+		.split(/\r?\n/)
+		.map(line => line.trim())
+		.filter(Boolean);
+}
 
 export type GjcWorkerCheckpointClassification =
 	| { kind: "clean"; files: string[] }
@@ -2323,17 +2422,14 @@ export type GjcWorkerCheckpointClassification =
 	| { kind: "git_error"; files: string[]; detail: string };
 
 const UNMERGED_GIT_STATUS_CODES = new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
-const PROTECTED_WORKER_CHECKPOINT_PREFIXES = [
-	".gjc/_session-*/state/",
-	".gjc/_session-*/logs/",
-	".gjc/_session-*/reports/",
-	".gjc/_session-*/runtime/",
-	".gjc/_session-*/ultragoal/",
-	".gjc/_session-*/plans/",
-	".gjc/_session-*/specs/",
-	".gjc/_session-*/rlm/",
-	".gjc/_session-*/audit/",
-];
+// Every generated/runtime artifact for a GJC session lives under
+// `.gjc/_session-{id}/...` (see session-layout.ts), so worker auto-checkpoints
+// exclude the whole session subtree instead of enumerating its subdirectories.
+// The enumerated form drifted: subtrees outside the list (for example the
+// extragoal gate receipts from docs/extragoal-skill-template.md, or the
+// session-root `.session-activity.json` marker) were auto-committed and merged
+// into the leader branch on projects that do not gitignore `.gjc/_session-*/`.
+const PROTECTED_WORKER_CHECKPOINT_PREFIXES = [".gjc/_session-*/"];
 
 function parsePorcelainStatusFiles(stdout: string): string[] {
 	return stdout
@@ -2384,6 +2480,26 @@ export function classifyWorkerCheckpointStatus(cwd: string): GjcWorkerCheckpoint
 		return { kind: "protected_only", files: classified.protected };
 	return { kind: "eligible", files: classified.eligible };
 }
+export async function classifyWorkerCheckpointStatusAsync(cwd: string): Promise<GjcWorkerCheckpointClassification> {
+	const status = await runGitResultAsync(cwd, ["status", "--porcelain", "-uall"]);
+	if (!status.ok) {
+		return { kind: "git_error", files: [], detail: status.stderr || status.stdout || "git status failed" };
+	}
+	if (!status.stdout.trim()) return { kind: "clean", files: [] };
+	const files = parsePorcelainStatusFiles(status.stdout);
+	const hasUnmergedStatus = status.stdout
+		.split(/\r?\n/)
+		.filter(Boolean)
+		.some(line => UNMERGED_GIT_STATUS_CODES.has(line.slice(0, 2)));
+	const conflictFiles = await listConflictFilesAsync(cwd);
+	if (hasUnmergedStatus || conflictFiles.length > 0) {
+		return { kind: "conflicted", files: conflictFiles.length > 0 ? conflictFiles : files };
+	}
+	const classified = classifyGjcTeamCheckpointFiles(files);
+	if (classified.eligible.length === 0 && classified.protected.length > 0)
+		return { kind: "protected_only", files: classified.protected };
+	return { kind: "eligible", files: classified.eligible };
+}
 async function appendIntegrationEvent(
 	dir: string,
 	type: string,
@@ -2861,6 +2977,7 @@ async function initializeStateDirs(dir: string, workers: GjcTeamWorker[]): Promi
 export async function startGjcTeam(options: GjcTeamStartOptions): Promise<GjcTeamSnapshot> {
 	const cwd = options.cwd ?? process.cwd();
 	const env = options.env ?? process.env;
+	if (options.mailboxDeliveryTransport) setGjcTeamMailboxDeliveryTransport(options.mailboxDeliveryTransport);
 	if (!Number.isInteger(options.workerCount) || options.workerCount < 1 || options.workerCount > GJC_TEAM_MAX_WORKERS)
 		throw new Error(`invalid_team_worker_count:${options.workerCount}:expected_1_${GJC_TEAM_MAX_WORKERS}`);
 	const workerCliPlan = resolveGjcTeamWorkerCliPlan(options.workerCount, env);
@@ -3042,13 +3159,15 @@ export async function requestGjcWorkerIntegrationAttempt(
 	const worker = env.GJC_TEAM_WORKER_ID?.trim() || env.GJC_TEAM_INTERNAL_WORKER?.split("/").pop()?.trim();
 	if (!teamName || !worker) return { requested: false, reason: "not_worker" };
 	const dir = await findTeamDir(teamName, cwd, env);
-	const config = await readConfig(dir);
+	const config = await readConfigForWorkerIntegration(dir);
 	const configuredWorker = config.workers.find(candidate => candidate.id === worker);
 	const worktreePath = env.GJC_TEAM_WORKTREE_PATH?.trim() || configuredWorker?.worktree_path;
 	if (!worktreePath || !(await pathExists(worktreePath)))
 		return { requested: false, reason: "missing_worktree", worker, team_name: teamName };
-	const classification = classifyWorkerCheckpointStatus(worktreePath);
-	const head = resolveHead(worktreePath);
+	const [classification, head] = await Promise.all([
+		classifyWorkerCheckpointStatusAsync(worktreePath),
+		resolveHeadAsync(worktreePath),
+	]);
 	if (classification.kind === "git_error") {
 		return { requested: false, reason: "git_error", worker, team_name: teamName, head, status: classification.kind };
 	}
@@ -3816,12 +3935,59 @@ async function reconcileTeamNotifications(dir: string, config: GjcTeamConfig): P
 	}
 	return summarizeNotifications(await listNotificationRecords(dir));
 }
+async function messageForNotification(
+	dir: string,
+	notification: GjcTeamNotification,
+): Promise<GjcTeamMailboxMessage | null> {
+	if (notification.kind !== "mailbox_message" || notification.source.type !== "message") return null;
+	const mailbox = await readMailbox(dir, notification.recipient);
+	return mailbox.messages.find(message => message.message_id === notification.source.id) ?? null;
+}
+
+async function attemptConfiguredMailboxTransport(
+	dir: string,
+	config: GjcTeamConfig,
+	notification: GjcTeamNotification,
+	cwd: string,
+	env: NodeJS.ProcessEnv,
+): Promise<GjcTeamNotification | null> {
+	if (!gjcTeamMailboxDeliveryTransport) return null;
+	const message = await messageForNotification(dir, notification);
+	if (!message) return null;
+	try {
+		const result = await gjcTeamMailboxDeliveryTransport.deliverMailboxMessage({
+			team_name: config.team_name,
+			state_dir: dir,
+			config,
+			notification,
+			message,
+			cwd,
+			env,
+		});
+		if (!result) return null;
+		if (result.transport === "notifications_sdk" && result.state === "failed") return null;
+		return writeNotificationRecord(dir, {
+			...notification,
+			delivery_state: result.state,
+			pane_attempt_result: result.transport === "pane" ? result.state : undefined,
+			pane_attempt_reason: result.reason ?? result.transport,
+			pane_attempt_at: now(),
+			updated_at: now(),
+		});
+	} catch {
+		return null;
+	}
+}
+
 async function attemptPaneNotification(
 	dir: string,
 	config: GjcTeamConfig,
 	notification: GjcTeamNotification,
 	env: NodeJS.ProcessEnv,
+	cwd = process.cwd(),
 ): Promise<GjcTeamNotification> {
+	const transported = await attemptConfiguredMailboxTransport(dir, config, notification, cwd, env);
+	if (transported) return transported;
 	const paneId =
 		notification.recipient === "leader-fixed"
 			? config.leader.pane_id
@@ -3868,6 +4034,7 @@ export async function replayGjcTeamNotifications(
 				replay_count: (notification.replay_count ?? 0) + 1,
 			},
 			env,
+			cwd,
 		);
 		next.push(attempted);
 	}
@@ -3896,8 +4063,13 @@ export async function sendGjcTeamMessage(
 		...(idempotencyKey ? { idempotency_key: idempotencyKey } : {}),
 	};
 	const written = await writeMailboxMessage(dir, toWorker, message);
+	const existingNotification = await readJsonFile<GjcTeamNotification>(
+		notificationPath(dir, messageNotificationId(config.team_name, toWorker, written.message_id)),
+	);
 	const notification = await createMessageNotification(dir, config.team_name, written);
-	await attemptPaneNotification(dir, config, notification, env);
+	if (!existingNotification) {
+		await attemptPaneNotification(dir, config, notification, env, cwd);
+	}
 	await appendEvent(dir, {
 		type: "message_sent",
 		worker: fromWorker,

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

@@ -1,17 +1,15 @@
 import * as fs from "node:fs/promises";
 import { DEFAULT_ULTRAGOAL_OBJECTIVE } from "./goal-mode-request";
 import { resolveGjcSessionForRead, SessionResolutionError } from "./session-resolution";
+import { validateDeferredMemberReceiptFresh, validateReceiptFreshBase } from "./ultragoal-receipt-freshness";
 import {
-	computeUltragoalPlanGeneration,
 	getUltragoalPaths,
 	getUltragoalRunCompletionState,
-	hashStructuredValue,
 	readUltragoalLedger,
 	readUltragoalPlan,
 	recordUltragoalNudgeIfBudgetRemaining,
 	resolveUltragoalNudgeBudget,
 	selectUltragoalNudgeTarget,
-	type UltragoalCompletionVerification,
 	type UltragoalGoal,
 	type UltragoalLedgerEvent,
 	type UltragoalNudgeSurface,
@@ -176,26 +174,6 @@ function findReceiptGoal(
 	return storyGoal ? { goal: storyGoal, receiptKind: "per-goal" } : null;
 }
 
-function findLedgerReceiptEvent(
-	ledger: readonly UltragoalLedgerEvent[],
-	receipt: UltragoalCompletionVerification,
-): UltragoalLedgerEvent | null {
-	return (
-		ledger.find(event => {
-			if (event.eventId !== receipt.checkpointLedgerEventId) return false;
-			if (event.event !== "goal_checkpointed") return false;
-			if (event.goalId !== receipt.goalId) return false;
-			const eventReceipt = event.completionVerification as UltragoalCompletionVerification | undefined;
-			return (
-				event.status === "complete" &&
-				eventReceipt?.receiptId === receipt.receiptId &&
-				eventReceipt.receiptKind === receipt.receiptKind &&
-				eventReceipt.planGeneration === receipt.planGeneration
-			);
-		}) ?? null
-	);
-}
-
 export function validateCompletionReceipt(input: {
 	plan: UltragoalPlan;
 	ledger: readonly UltragoalLedgerEvent[];
@@ -210,55 +188,66 @@ export function validateCompletionReceipt(input: {
 			goalId: input.goal.id,
 		};
 	}
-	if (
-		receipt.schemaVersion !== 1 ||
-		receipt.goalId !== input.goal.id ||
-		receipt.receiptKind !== input.receiptKind ||
-		!receipt.planGeneration ||
-		!receipt.checkpointLedgerEventId
-	) {
-		return {
-			state: "active_stale_receipt",
-			message: `Ultragoal ${input.goal.id} receipt is malformed or stale.`,
-			goalId: input.goal.id,
-		};
-	}
-	const event = findLedgerReceiptEvent(input.ledger, receipt);
-	if (!event) {
-		return {
-			state: "active_stale_receipt",
-			message: `Ultragoal ${input.goal.id} receipt ledger event is missing.`,
-			goalId: input.goal.id,
-		};
+	if (receipt.validationBatch?.role === "deferred-member") {
+		return validateDeferredMemberReceiptFresh({
+			plan: input.plan,
+			ledger: input.ledger,
+			goal: input.goal,
+			receipt,
+			receiptKind: input.receiptKind,
+			requireClose: true,
+		});
 	}
-	const generation = computeUltragoalPlanGeneration({
+	const baseDiagnostic = validateReceiptFreshBase({
 		plan: input.plan,
 		ledger: input.ledger,
 		goal: input.goal,
+		receipt,
 		receiptKind: input.receiptKind,
-		beforeStatus: receipt.goalStatusBeforeCheckpoint,
-		excludeEventId: receipt.checkpointLedgerEventId,
 	});
-	if (generation.planGeneration !== receipt.planGeneration) {
-		return {
-			state: "active_stale_receipt",
-			message: `Ultragoal ${input.goal.id} receipt generation is stale.`,
-			goalId: input.goal.id,
-		};
-	}
-	if (hashStructuredValue(event.qualityGateJson) !== receipt.qualityGateHash) {
-		return {
-			state: "active_dirty_quality_gate",
-			message: `Ultragoal ${input.goal.id} receipt quality-gate hash does not match ledger.`,
-			goalId: input.goal.id,
-		};
-	}
-	if (input.goal.updatedAt !== receipt.verifiedAt) {
-		return {
-			state: "active_stale_receipt",
-			message: `Ultragoal ${input.goal.id} receipt target changed after verification.`,
-			goalId: input.goal.id,
-		};
+	if (baseDiagnostic) return baseDiagnostic;
+	if (receipt.validationBatch?.role === "batch-close") {
+		for (const memberId of receipt.validationBatch.memberIds) {
+			const member = input.plan.goals.find(goal => goal.id === memberId);
+			if (
+				!member?.validationBatch ||
+				member.validationBatch.metadataHash !== receipt.validationBatch.memberMetadataHashes[memberId]
+			) {
+				return {
+					state: "active_stale_receipt",
+					message: `Ultragoal ${input.goal.id} batch-close receipt has stale member metadata for ${memberId}.`,
+					goalId: input.goal.id,
+				};
+			}
+			if (memberId === receipt.validationBatch.finalGoalId) continue;
+			const memberReceipt = member.completionVerification;
+			if (memberReceipt?.validationBatch?.role !== "deferred-member") {
+				return {
+					state: "active_missing_final_receipt",
+					message: `Ultragoal ${input.goal.id} batch-close receipt requires deferred member receipt for ${memberId}.`,
+					goalId: input.goal.id,
+				};
+			}
+			const memberDiagnostic = validateDeferredMemberReceiptFresh({
+				plan: input.plan,
+				ledger: input.ledger,
+				goal: member,
+				receipt: memberReceipt,
+				receiptKind: "per-goal",
+				requireClose: false,
+			});
+			if (memberDiagnostic.state !== "active_verified_complete") return memberDiagnostic;
+			if (
+				receipt.validationBatch.memberReceiptIds[memberId] !== memberReceipt.receiptId ||
+				receipt.validationBatch.memberChangeSetHashes[memberId] !== memberReceipt.validationBatch.changeSetHash
+			) {
+				return {
+					state: "active_stale_receipt",
+					message: `Ultragoal ${input.goal.id} batch-close receipt is stale for deferred member ${memberId}.`,
+					goalId: input.goal.id,
+				};
+			}
+		}
 	}
 	if (input.receiptKind === "final-aggregate") {
 		const incomplete = requiredGoals(input.plan).filter(goal => goal.status !== "complete");