@gajae-code/coding-agent 0.6.3 → 0.6.5

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

@@ -114,7 +114,13 @@ function runListSessions(format: string, env: NodeJS.ProcessEnv = process.env):
 		output = runTmux(["list-sessions", "-F", format], env);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		if (message.includes("no server running") || message.includes("failed to connect to server")) return [];
+		if (
+			message.includes("no server running") ||
+			message.includes("failed to connect to server") ||
+			message.includes("error connecting to")
+		) {
+			return [];
+		}
 		throw error;
 	}
 	return output
@@ -137,6 +143,8 @@ function listRawTmuxSessionNames(env: NodeJS.ProcessEnv = process.env): string[]
 export function listGjcTmuxSessions(env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus[] {
 	return listSessionLines(env)
 		.map(parseSessionLine)
+		.filter((session): session is GjcTmuxSessionStatus => session != null)
+		.map(session => hydrateSessionFromExactOptions(session, env))
 		.filter((session): session is GjcTmuxSessionStatus => session?.profile === GJC_TMUX_PROFILE_VALUE)
 		.sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -145,7 +153,8 @@ export function listGjcTmuxSessions(env: NodeJS.ProcessEnv = process.env): GjcTm
 export function listTmuxSessionsForGc(env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionsForGc {
 	const sessions = listSessionLines(env)
 		.map(parseSessionLine)
-		.filter((session): session is GjcTmuxSessionStatus => session != null);
+		.filter((session): session is GjcTmuxSessionStatus => session != null)
+		.map(session => hydrateSessionFromExactOptions(session, env));
 	const tagged = sessions
 		.filter(session => session.profile === GJC_TMUX_PROFILE_VALUE)
 		.sort((a, b) => a.name.localeCompare(b.name));
@@ -179,6 +188,22 @@ export function findGjcTmuxSessionByBranch(
 	);
 }
 
+export function findGjcTmuxSessionByName(
+	sessionName: string,
+	env: NodeJS.ProcessEnv = process.env,
+): GjcTmuxSessionStatus | undefined {
+	return listGjcTmuxSessions(env).find(session => session.name === sessionName);
+}
+
+export function findGjcTmuxSessionByScope(
+	project: string,
+	branch: string | null | undefined,
+	env: NodeJS.ProcessEnv = process.env,
+): GjcTmuxSessionStatus | undefined {
+	return listGjcTmuxSessions(env).find(
+		session => session.project === project && (branch ? session.branch === branch : session.branch === undefined),
+	);
+}
 export function statusGjcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus {
 	const session = listGjcTmuxSessions(env).find(candidate => candidate.name === sessionName);
 	if (session) return session;
@@ -227,6 +252,22 @@ function readExactOptionForGc(sessionName: string, option: string, env: NodeJS.P
 	}
 }
 
+function hydrateSessionFromExactOptions(session: GjcTmuxSessionStatus, env: NodeJS.ProcessEnv): GjcTmuxSessionStatus {
+	if (session.profile === GJC_TMUX_PROFILE_VALUE) return session;
+	const profile = readExactOptionForGc(session.name, GJC_TMUX_PROFILE_OPTION, env);
+	if (profile !== GJC_TMUX_PROFILE_VALUE) return session;
+	return {
+		...session,
+		profile,
+		branch: session.branch ?? readExactOptionForGc(session.name, GJC_TMUX_BRANCH_OPTION, env),
+		branchSlug: session.branchSlug ?? readExactOptionForGc(session.name, GJC_TMUX_BRANCH_SLUG_OPTION, env),
+		project: session.project ?? readExactOptionForGc(session.name, GJC_TMUX_PROJECT_OPTION, env),
+		sessionId: session.sessionId ?? readExactOptionForGc(session.name, GJC_TMUX_SESSION_ID_OPTION, env),
+		sessionStateFile:
+			session.sessionStateFile ?? readExactOptionForGc(session.name, GJC_TMUX_SESSION_STATE_FILE_OPTION, env),
+	};
+}
+
 /** @internal */
 export function readTmuxSessionTagsForGc(
 	sessionName: string,

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

@@ -1,5 +1,6 @@
 import * as fs from "node:fs/promises";
 import { DEFAULT_ULTRAGOAL_OBJECTIVE } from "./goal-mode-request";
+import { resolveGjcSessionForRead, SessionResolutionError } from "./session-resolution";
 import {
 	computeUltragoalPlanGeneration,
 	getUltragoalPaths,
@@ -10,6 +11,7 @@ import {
 	type UltragoalCompletionVerification,
 	type UltragoalGoal,
 	type UltragoalLedgerEvent,
+	type UltragoalPaths,
 	type UltragoalPlan,
 	type UltragoalReceiptKind,
 } from "./ultragoal-runtime";
@@ -63,9 +65,30 @@ function isKnownUltragoalObjective(currentObjective: string): boolean {
 	);
 }
 
+async function ultragoalReadPaths(cwd: string): Promise<UltragoalPaths> {
+	const envSessionId = process.env.GJC_SESSION_ID?.trim();
+	if (envSessionId) return getUltragoalPaths(cwd, envSessionId);
+	try {
+		const session = await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID });
+		return getUltragoalPaths(cwd, session.gjcSessionId);
+	} catch (error) {
+		if (error instanceof SessionResolutionError && error.code === "no_session") {
+			return getUltragoalPaths(cwd, null);
+		}
+		throw error;
+	}
+}
+
 async function hasDurableUltragoalState(cwd: string): Promise<boolean> {
+	let paths: UltragoalPaths;
+	try {
+		paths = await ultragoalReadPaths(cwd);
+	} catch (error) {
+		if (error instanceof SessionResolutionError) return true;
+		throw error;
+	}
 	try {
-		await fs.stat(getUltragoalPaths(cwd).dir);
+		await fs.stat(paths.dir);
 		return true;
 	} catch (error) {
 		if (
@@ -308,6 +331,18 @@ export async function readUltragoalVerificationState(input: {
 	}
 	const receiptTarget = findReceiptGoal(plan, currentObjective);
 	if (!receiptTarget) {
+		// When earlier required goals are already complete but later ones remain, name the
+		// specific blocking goals (a final-aggregate receipt cannot exist yet anyway). Only
+		// fall back to the generic missing-receipt message when no progress has been verified.
+		const completedRequired = requiredGoals(plan).filter(goal => goal.status === "complete");
+		if (completedRequired.length > 0 && runState.incompleteGoals.length > 0) {
+			return {
+				state: "active_missing_final_receipt",
+				message: `Ultragoal still has incomplete required goals: ${runState.incompleteGoals
+					.map(goal => goal.id)
+					.join(", ")}. Run \`gjc ultragoal complete-goals\` to continue.`,
+			};
+		}
 		return {
 			state: "active_missing_final_receipt",
 			message: "Ultragoal aggregate completion requires a fresh final aggregate receipt.",
@@ -331,7 +366,15 @@ export async function readUltragoalVerificationState(input: {
 }
 
 export async function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBlockDiagnostic> {
-	const paths = getUltragoalPaths(cwd);
+	let paths: UltragoalPaths;
+	try {
+		paths = await ultragoalReadPaths(cwd);
+	} catch (error) {
+		return activeAskDiagnostic({
+			reason: `Unable to resolve durable Ultragoal state: ${error instanceof Error ? error.message : String(error)}`,
+			source: "durable_state_unreadable",
+		});
+	}
 	try {
 		await fs.stat(paths.dir);
 	} catch (error) {

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

@@ -6,10 +6,11 @@ import type { WorkflowHudSummary } from "../skill-state/active-state";
 import { buildUltragoalHudSummary as buildWorkflowUltragoalHudSummary } from "../skill-state/workflow-hud";
 import { renderCliWriteReceipt } from "./cli-write-receipt";
 import { DEFAULT_ULTRAGOAL_OBJECTIVE } from "./goal-mode-request";
-import { latestUltragoalLedgerEventFromText } from "./ledger-event-renderer";
+import { gjcRoot, sessionUltragoalDir } from "./session-layout";
+import { resolveGjcSessionForRead, resolveGjcSessionForWrite, writeSessionActivityMarker } from "./session-resolution";
 import { renderUltragoalStatusMarkdown } from "./state-renderer";
 import { reconcileWorkflowSkillState } from "./state-runtime";
-import { appendJsonl, writeArtifact, writeJsonAtomic } from "./state-writer";
+import { appendJsonl, persistedStateRevision, writeArtifact, writeGuardedJsonAtomic } from "./state-writer";
 
 export type UltragoalGjcGoalMode = "aggregate" | "per-story";
 export type UltragoalGoalStatus =
@@ -44,6 +45,7 @@ export interface UltragoalPlan {
 	goals: UltragoalGoal[];
 	createdAt: string;
 	updatedAt: string;
+	[key: string]: unknown;
 }
 
 export type UltragoalReceiptKind = "per-goal" | "final-aggregate";
@@ -107,6 +109,10 @@ interface JsonObject {
 	[key: string]: unknown;
 }
 
+function currentUltragoalSessionId(cwd: string): string {
+	return resolveGjcSessionForWrite(cwd, { envSessionId: process.env.GJC_SESSION_ID }).gjcSessionId;
+}
+
 const TERMINAL_OR_SKIPPED_STATUSES = new Set<UltragoalGoalStatus>(["complete", "superseded"]);
 const CLEAN_ARCHITECT_STATUS = "CLEAR";
 const APPROVE_RECOMMENDATION = "APPROVE";
@@ -162,8 +168,9 @@ export function hashStructuredValue(value: unknown): string {
 		.digest("hex");
 }
 
-export function getUltragoalPaths(cwd: string): UltragoalPaths {
-	const dir = path.join(cwd, ".gjc", "ultragoal");
+export function getUltragoalPaths(cwd: string, sessionId?: string | null): UltragoalPaths {
+	const explicitSessionId = sessionId?.trim() || process.env.GJC_SESSION_ID?.trim();
+	const dir = explicitSessionId ? sessionUltragoalDir(cwd, explicitSessionId) : path.join(gjcRoot(cwd), "ultragoal");
 	return {
 		dir,
 		briefPath: path.join(dir, "brief.md"),
@@ -178,8 +185,10 @@ function isEnoent(error: unknown): boolean {
 	);
 }
 
-async function appendLedger(cwd: string, event: JsonObject): Promise<UltragoalLedgerEvent> {
-	const paths = getUltragoalPaths(cwd);
+async function appendLedger(cwd: string, event: JsonObject, sessionId?: string | null): Promise<UltragoalLedgerEvent> {
+	const resolvedSessionId =
+		sessionId?.trim() || resolveGjcSessionForWrite(cwd, { envSessionId: process.env.GJC_SESSION_ID }).gjcSessionId;
+	const paths = getUltragoalPaths(cwd, resolvedSessionId);
 	const entry: UltragoalLedgerEvent = {
 		eventId: typeof event.eventId === "string" ? event.eventId : crypto.randomUUID(),
 		...event,
@@ -187,14 +196,18 @@ async function appendLedger(cwd: string, event: JsonObject): Promise<UltragoalLe
 	};
 	await appendJsonl(paths.ledgerPath, entry, {
 		cwd,
-		audit: { category: "ledger", verb: "append", owner: "gjc-runtime" },
+		audit: { category: "ledger", verb: "append", owner: "gjc-runtime", sessionId: resolvedSessionId },
 	});
+	await writeSessionActivityMarker(cwd, resolvedSessionId, { writer: "ultragoal-runtime", path: paths.ledgerPath });
 	return entry;
 }
 
-export async function readUltragoalLedger(cwd: string): Promise<UltragoalLedgerEvent[]> {
+export async function readUltragoalLedger(cwd: string, sessionId?: string | null): Promise<UltragoalLedgerEvent[]> {
+	const resolvedSessionId =
+		sessionId?.trim() ||
+		(await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID })).gjcSessionId;
 	try {
-		const raw = await Bun.file(getUltragoalPaths(cwd).ledgerPath).text();
+		const raw = await Bun.file(getUltragoalPaths(cwd, resolvedSessionId).ledgerPath).text();
 		return raw
 			.split(/\r?\n/)
 			.map(line => line.trim())
@@ -206,16 +219,21 @@ export async function readUltragoalLedger(cwd: string): Promise<UltragoalLedgerE
 	}
 }
 
-async function writePlan(cwd: string, plan: UltragoalPlan): Promise<void> {
-	const paths = getUltragoalPaths(cwd);
+async function writePlan(cwd: string, plan: UltragoalPlan, sessionId?: string | null): Promise<void> {
+	const resolvedSessionId =
+		sessionId?.trim() || resolveGjcSessionForWrite(cwd, { envSessionId: process.env.GJC_SESSION_ID }).gjcSessionId;
+	const paths = getUltragoalPaths(cwd, resolvedSessionId);
 	await writeArtifact(paths.briefPath, `${plan.brief.trim()}\n`, {
 		cwd,
-		audit: { category: "artifact", verb: "write", owner: "gjc-runtime" },
+		audit: { category: "artifact", verb: "write", owner: "gjc-runtime", sessionId: resolvedSessionId },
 	});
-	await writeJsonAtomic(paths.goalsPath, plan, {
+	await writeGuardedJsonAtomic(paths.goalsPath, plan, {
 		cwd,
-		audit: { category: "state", verb: "write", owner: "gjc-runtime" },
+		policy: "source",
+		expectedRevision: typeof plan.state_revision === "number" ? persistedStateRevision(plan) : undefined,
+		audit: { category: "state", verb: "write", owner: "gjc-runtime", sessionId: resolvedSessionId },
 	});
+	await writeSessionActivityMarker(cwd, resolvedSessionId, { writer: "ultragoal-runtime", path: paths.goalsPath });
 }
 
 function requiredUltragoalGoals(plan: UltragoalPlan): UltragoalGoal[] {
@@ -426,6 +444,7 @@ function normalizePlan(raw: unknown): UltragoalPlan {
 		const objective = nonEmptyString(goalRecord.objective) ?? title;
 		const goalCreatedAt = nonEmptyString(goalRecord.createdAt) ?? createdAt;
 		return {
+			...goalRecord,
 			id,
 			title,
 			objective,
@@ -459,12 +478,18 @@ function normalizePlan(raw: unknown): UltragoalPlan {
 		goals,
 		createdAt,
 		updatedAt,
+		...(typeof record.state_revision === "number" && Number.isFinite(record.state_revision)
+			? { state_revision: record.state_revision }
+			: {}),
 	};
 }
 
-export async function readUltragoalPlan(cwd: string): Promise<UltragoalPlan | null> {
+export async function readUltragoalPlan(cwd: string, sessionId?: string | null): Promise<UltragoalPlan | null> {
+	const resolvedSessionId =
+		sessionId?.trim() ||
+		(await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID })).gjcSessionId;
 	try {
-		return normalizePlan(await Bun.file(getUltragoalPaths(cwd).goalsPath).json());
+		return normalizePlan(await Bun.file(getUltragoalPaths(cwd, resolvedSessionId).goalsPath).json());
 	} catch (error) {
 		if (isEnoent(error)) return null;
 		throw error;
@@ -483,9 +508,12 @@ function emptyCounts(): Record<UltragoalGoalStatus, number> {
 	};
 }
 
-export async function getUltragoalStatus(cwd: string): Promise<UltragoalStatusSummary> {
-	const paths = getUltragoalPaths(cwd);
-	const plan = await readUltragoalPlan(cwd);
+export async function getUltragoalStatus(cwd: string, sessionId?: string | null): Promise<UltragoalStatusSummary> {
+	const resolvedSessionId =
+		sessionId?.trim() ||
+		(await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID })).gjcSessionId;
+	const paths = getUltragoalPaths(cwd, resolvedSessionId);
+	const plan = await readUltragoalPlan(cwd, resolvedSessionId);
 	const counts = emptyCounts();
 	if (!plan) return { exists: false, status: "missing", paths, counts, goals: [] };
 	for (const goal of plan.goals) counts[goal.status] += 1;
@@ -577,6 +605,7 @@ export async function createUltragoalPlan(input: {
 	cwd: string;
 	brief: string;
 	gjcGoalMode?: UltragoalGjcGoalMode;
+	sessionId?: string | null;
 }): Promise<UltragoalPlan> {
 	const brief = input.brief.trim();
 	if (!brief) throw new Error("ultragoal brief is required");
@@ -601,8 +630,8 @@ export async function createUltragoalPlan(input: {
 		createdAt: now,
 		updatedAt: now,
 	};
-	await writePlan(input.cwd, plan);
-	await appendLedger(input.cwd, { event: "plan_created", goalIds: plan.goals.map(goal => goal.id) });
+	await writePlan(input.cwd, plan, input.sessionId);
+	await appendLedger(input.cwd, { event: "plan_created", goalIds: plan.goals.map(goal => goal.id) }, input.sessionId);
 	return plan;
 }
 
@@ -639,12 +668,16 @@ export function getUltragoalRunCompletionState(
 	};
 }
 
-export async function startNextUltragoalGoal(input: { cwd: string; retryFailed?: boolean }): Promise<{
+export async function startNextUltragoalGoal(input: {
+	cwd: string;
+	retryFailed?: boolean;
+	sessionId?: string | null;
+}): Promise<{
 	plan: UltragoalPlan;
 	goal?: UltragoalGoal;
 	allComplete: boolean;
 }> {
-	const plan = await readUltragoalPlan(input.cwd);
+	const plan = await readUltragoalPlan(input.cwd, input.sessionId);
 	if (!plan) throw new Error("No ultragoal plan found. Run `gjc ultragoal create-goals --brief ...` first.");
 	const goal = chooseNextGoal(plan, input.retryFailed === true);
 	if (!goal) return { plan, allComplete: getUltragoalRunCompletionState(plan).allComplete };
@@ -654,8 +687,8 @@ export async function startNextUltragoalGoal(input: { cwd: string; retryFailed?:
 		goal.startedAt = goal.startedAt ?? now;
 		goal.updatedAt = now;
 		plan.updatedAt = now;
-		await writePlan(input.cwd, plan);
-		await appendLedger(input.cwd, { event: "goal_started", goalId: goal.id });
+		await writePlan(input.cwd, plan, input.sessionId);
+		await appendLedger(input.cwd, { event: "goal_started", goalId: goal.id }, input.sessionId);
 	}
 	return { plan, goal, allComplete: false };
 }
@@ -2350,6 +2383,8 @@ export async function checkpointUltragoalGoal(input: {
 	if (input.status === "complete") goal.completedAt = now;
 	plan.updatedAt = now;
 	await writePlan(input.cwd, plan);
+	const persistedPlan = await readUltragoalPlan(input.cwd);
+	if (persistedPlan?.state_revision !== undefined) plan.state_revision = persistedPlan.state_revision;
 	await appendLedger(input.cwd, {
 		eventId: pendingCheckpointEventId,
 		event: "goal_checkpointed",
@@ -2799,6 +2834,8 @@ export async function recordUltragoalReviewBlockers(input: {
 		evidence: input.evidence,
 		gjcGoalJson: input.gjcGoalJson,
 	});
+	const persistedPlan = await readUltragoalPlan(input.cwd);
+	if (persistedPlan?.state_revision !== undefined) plan.state_revision = persistedPlan.state_revision;
 	const now = new Date().toISOString();
 	const nextId = `G${String(plan.goals.length + 1).padStart(3, "0")}`;
 	plan.goals.push({
@@ -3329,7 +3366,7 @@ function renderCompleteHandoff(
 			goal_id: result.goal?.id,
 			goal_status: result.goal?.status,
 			gjc_objective: result.plan.gjcObjective,
-			goals_path: getUltragoalPaths(cwd).goalsPath,
+			goals_path: getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).goalsPath,
 		});
 	}
 	if (result.allComplete) return "ultragoal complete all=true\n";
@@ -3353,7 +3390,7 @@ function renderCheckpointContinuation(
 			ok: true,
 			goal_id: result.checkpointedGoal.id,
 			status,
-			goals_path: getUltragoalPaths(cwd).goalsPath,
+			goals_path: getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).goalsPath,
 			completion_receipt_kind: result.checkpointedGoal.completionVerification?.receiptKind,
 			quality_gate_hash: result.checkpointedGoal.completionVerification?.qualityGateHash,
 			all_complete: result.allComplete,
@@ -3407,7 +3444,12 @@ async function executeUltragoalSteeringCommand(args: readonly string[], cwd: str
 				return {
 					kind,
 					message: "Accepted add_subgoal steering.\n",
-					receipt: { ok: true, kind, goal_id: result.goalId, goals_path: getUltragoalPaths(cwd).goalsPath },
+					receipt: {
+						ok: true,
+						kind,
+						goal_id: result.goalId,
+						goals_path: getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).goalsPath,
+					},
 				};
 			}
 			case "split_subgoal": {
@@ -3427,7 +3469,7 @@ async function executeUltragoalSteeringCommand(args: readonly string[], cwd: str
 						kind,
 						goal_id: result.goalId,
 						replacement_goal_ids: result.replacementGoalIds,
-						goals_path: getUltragoalPaths(cwd).goalsPath,
+						goals_path: getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).goalsPath,
 					},
 				};
 			}
@@ -3446,7 +3488,7 @@ async function executeUltragoalSteeringCommand(args: readonly string[], cwd: str
 						ok: true,
 						kind,
 						pending_goal_ids: result.pendingGoalIds,
-						goals_path: getUltragoalPaths(cwd).goalsPath,
+						goals_path: getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).goalsPath,
 					},
 				};
 			}
@@ -3468,7 +3510,7 @@ async function executeUltragoalSteeringCommand(args: readonly string[], cwd: str
 						kind,
 						goal_id: result.goalId,
 						changed_fields: result.changedFields,
-						goals_path: getUltragoalPaths(cwd).goalsPath,
+						goals_path: getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).goalsPath,
 					},
 				};
 			}
@@ -3477,7 +3519,11 @@ async function executeUltragoalSteeringCommand(args: readonly string[], cwd: str
 				return {
 					kind,
 					message: "Accepted annotate_ledger steering.\n",
-					receipt: { ok: true, kind, ledger_path: getUltragoalPaths(cwd).ledgerPath },
+					receipt: {
+						ok: true,
+						kind,
+						ledger_path: getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).ledgerPath,
+					},
 				};
 			}
 			case "mark_blocked_superseded": {
@@ -3496,7 +3542,7 @@ async function executeUltragoalSteeringCommand(args: readonly string[], cwd: str
 						kind,
 						goal_id: result.goalId,
 						no_replacement_required: true,
-						goals_path: getUltragoalPaths(cwd).goalsPath,
+						goals_path: getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).goalsPath,
 					},
 				};
 			}
@@ -3517,6 +3563,7 @@ async function executeUltragoalSteeringCommand(args: readonly string[], cwd: str
 }
 
 async function dispatchUltragoalCommand(args: string[], cwd: string): Promise<UltragoalCommandResult> {
+	const sessionId = currentUltragoalSessionId(cwd);
 	const help = renderUltragoalHelp(args);
 	if (help) return { status: 0, stdout: help };
 	try {
@@ -3524,7 +3571,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), json) };
+				return { status: 0, stdout: renderStatus(await getUltragoalStatus(cwd, sessionId), json) };
 			case "create":
 			case "create-goals": {
 				const mode = flagValue(args, "--gjc-goal-mode") === "per-story" ? "per-story" : "aggregate";
@@ -3537,9 +3584,9 @@ async function dispatchUltragoalCommand(args: string[], cwd: string): Promise<Ul
 								ok: true,
 								goals_count: plan.goals.length,
 								goal_ids: plan.goals.map(goal => goal.id),
-								goals_path: getUltragoalPaths(cwd).goalsPath,
+								goals_path: getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).goalsPath,
 							})
-						: `Created ultragoal plan with ${plan.goals.length} goal${plan.goals.length === 1 ? "" : "s"} at ${getUltragoalPaths(cwd).goalsPath}.\n`,
+						: `Created ultragoal plan with ${plan.goals.length} goal${plan.goals.length === 1 ? "" : "s"} at ${getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).goalsPath}.\n`,
 				};
 			}
 			case "complete-goals":
@@ -3598,7 +3645,11 @@ async function dispatchUltragoalCommand(args: string[], cwd: string): Promise<Ul
 				return {
 					status: 0,
 					stdout: json
-						? renderCliWriteReceipt({ ok: true, goal_id: goal?.id, goals_path: getUltragoalPaths(cwd).goalsPath })
+						? renderCliWriteReceipt({
+								ok: true,
+								goal_id: goal?.id,
+								goals_path: getUltragoalPaths(cwd, currentUltragoalSessionId(cwd)).goalsPath,
+							})
 						: "Recorded review blockers.\n",
 				};
 			}
@@ -3632,9 +3683,9 @@ const RECONCILE_COMMANDS = new Set([
  * beyond that reconcile-failure audit event.
  */
 async function reconcileUltragoalState(cwd: string): Promise<void> {
-	const sessionId = process.env.GJC_SESSION_ID?.trim() || undefined;
+	const sessionId = currentUltragoalSessionId(cwd);
 	try {
-		const summary = await getUltragoalStatus(cwd);
+		const summary = await getUltragoalStatus(cwd, sessionId);
 		const status = summary.status;
 		const active = summary.exists && status !== "complete";
 		const payload: Record<string, unknown> = {
@@ -3653,15 +3704,44 @@ async function reconcileUltragoalState(cwd: string): Promise<void> {
 		const ledgerText = await Bun.file(summary.paths.ledgerPath)
 			.text()
 			.catch(() => "");
-		const latestLedger = latestUltragoalLedgerEventFromText(ledgerText);
+		const latestLedger = ledgerText
+			.split(/\r?\n/)
+			.map(line => line.trim())
+			.filter(Boolean)
+			.toReversed()
+			.map(line => {
+				try {
+					const row = JSON.parse(line) as Record<string, unknown>;
+					const event =
+						typeof row.event === "string" ? row.event : typeof row.type === "string" ? row.type : undefined;
+					return event ? { ...row, event } : undefined;
+				} catch {
+					return undefined;
+				}
+			})
+			.find((row): row is Record<string, unknown> & { event: string } => Boolean(row));
 		if (latestLedger) {
 			payload.latestLedgerEvent = {
 				event: latestLedger.event,
 				...(latestLedger.goalId ? { goalId: latestLedger.goalId } : {}),
 				...(latestLedger.timestamp ? { timestamp: latestLedger.timestamp } : {}),
+				...(typeof latestLedger.kind === "string" ? { kind: latestLedger.kind } : {}),
+				...(typeof latestLedger.evidence === "string" ? { evidence: latestLedger.evidence } : {}),
 			};
 		}
-		await reconcileWorkflowSkillState({ cwd, mode: "ultragoal", sessionId, active, phase: status, payload });
+		const sourceRevision = Math.max(
+			persistedStateRevision(await readUltragoalPlan(cwd, sessionId)),
+			ledgerText.split(/\r?\n/).filter(line => line.trim().length > 0).length,
+		);
+		await reconcileWorkflowSkillState({
+			cwd,
+			mode: "ultragoal",
+			sessionId,
+			active,
+			phase: status,
+			payload,
+			...(sourceRevision > 0 ? { sourceRevision } : {}),
+		});
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		process.stderr.write(`ultragoal state reconciliation failed: ${message}\n`);

package/src/gjc-runtime/workflow-command-ref.ts

@@ -1,5 +1,4 @@
-import type { CanonicalGjcWorkflowSkill } from "../skill-state/active-state";
-import { CANONICAL_GJC_WORKFLOW_SKILLS } from "../skill-state/active-state";
+import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill } from "../skill-state/canonical-skills";
 
 export type CommandRefVisibility = "public" | "hidden" | "planned";
 export type CommandRefIncludeWhen = "implemented-only" | "planned";

package/src/gjc-runtime/workflow-manifest.ts

@@ -4,8 +4,7 @@
  * hand-edited.
  */
 
-import type { CanonicalGjcWorkflowSkill } from "../skill-state/active-state";
-import { CANONICAL_GJC_WORKFLOW_SKILLS } from "../skill-state/active-state";
+import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill } from "../skill-state/canonical-skills";
 import { initialPhaseForSkill } from "../skill-state/initial-phase";
 
 export interface WorkflowState {

package/src/harness-control-plane/storage.ts

@@ -1,7 +1,7 @@
 /**
  * Session-scoped storage for the harness control plane.
  *
- * Layout (under the harness state root, default `<cwd>/.gjc/state/harness`):
+ * Layout (under the harness state root, default `<cwd>/.gjc/_session-{sessionid}/state/harness`):
  *   sessions/<encoded-id>/state.json        lifecycle + handle (atomic)
  *   sessions/<encoded-id>/lease.json         owner lease (M3)
  *   sessions/<encoded-id>/events.jsonl       owner-only severity envelopes
@@ -18,6 +18,7 @@ import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import { harnessStateRoot } from "../gjc-runtime/session-layout";
 import { appendReceiptToConfiguredSpool } from "./receipt-spool";
 import type { ReceiptEnvelope } from "./receipts";
 import type { EventEnvelope, ReceiptFamily, SessionState } from "./types";
@@ -232,13 +233,22 @@ export class StorageError extends Error {
 	}
 }
 
-/** Resolve the harness state root from explicit value, env, or cwd default. */
-export function resolveHarnessRoot(opts?: { root?: string; cwd?: string; env?: NodeJS.ProcessEnv }): string {
+/** Resolve the harness state root from explicit value, env, or cwd/session default. */
+export function resolveHarnessRoot(opts?: {
+	root?: string;
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	gjcSessionId?: string;
+}): string {
 	const env = opts?.env ?? process.env;
 	if (opts?.root) return path.resolve(opts.root);
 	const fromEnv = env.GJC_HARNESS_STATE_ROOT;
 	if (fromEnv?.trim()) return path.resolve(fromEnv.trim());
-	return path.join(opts?.cwd ?? process.cwd(), ".gjc", "state", "harness");
+	const gjcSessionId = opts?.gjcSessionId ?? env.GJC_SESSION_ID?.trim();
+	if (!gjcSessionId) {
+		throw new StorageError("GJC session id is required for default harness state root", "missing_gjc_session_id");
+	}
+	return harnessStateRoot(opts?.cwd ?? process.cwd(), gjcSessionId);
 }
 
 export function assertSafeSessionId(id: string): void {