@gajae-code/coding-agent 0.6.4 → 0.6.5

package/src/extensibility/gjc-plugins/injection.ts

@@ -1,3 +1,16 @@
+import { resolveGjcSessionForRead, SessionResolutionError } from "../../gjc-runtime/session-resolution";
+
+async function resolveBoundarySessionId(cwd: string, sessionId?: string): Promise<string | undefined> {
+	const normalizedSessionId = sessionId?.trim();
+	if (normalizedSessionId) return normalizedSessionId;
+	try {
+		return (await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID })).gjcSessionId;
+	} catch (error) {
+		if (error instanceof SessionResolutionError && error.code === "no_session") return undefined;
+		throw error;
+	}
+}
+
 import { readVisibleSkillActiveState } from "../../skill-state/active-state";
 import { initialPhaseForSkill } from "../../skill-state/initial-phase";
 import { readActiveSubskillsForParent } from "./state";
@@ -35,7 +48,8 @@ export async function resolveCurrentPhaseForParent(input: {
 	const explicitPhase = input.explicitPhase?.trim();
 	if (explicitPhase) return explicitPhase;
 
-	const state = await readVisibleSkillActiveState(input.cwd, input.sessionId);
+	const resolvedSessionId = await resolveBoundarySessionId(input.cwd, input.sessionId);
+	const state = resolvedSessionId ? await readVisibleSkillActiveState(input.cwd, resolvedSessionId) : null;
 	const persistedPhase = state?.active_skills?.find(entry => entry.skill === input.parent)?.phase?.trim();
 	if (persistedPhase) return persistedPhase;
 
@@ -54,9 +68,10 @@ export async function buildSubskillInjection(input: {
 	activation?: LoadedSubskillActivation;
 	currentPhase?: string;
 }): Promise<{ block: string; details?: LoadedSubskillActivation } | null> {
+	const resolvedSessionId = await resolveBoundarySessionId(input.cwd, input.sessionId);
 	const resolvedPhase = await resolveCurrentPhaseForParent({
 		cwd: input.cwd,
-		sessionId: input.sessionId,
+		sessionId: resolvedSessionId,
 		parent: input.skillName,
 		explicitPhase: input.currentPhase,
 	});
@@ -67,9 +82,11 @@ export async function buildSubskillInjection(input: {
 		return { block: wrapSubskillBlock(directActivation, body), details: directActivation };
 	}
 
+	if (!resolvedSessionId) return null;
+
 	const [entry] = await readActiveSubskillsForParent({
 		cwd: input.cwd,
-		sessionId: input.sessionId,
+		sessionId: resolvedSessionId,
 		parent: input.skillName,
 		phase: resolvedPhase,
 	});
@@ -96,9 +113,11 @@ export async function buildAgentSubskillInjection(input: {
 }): Promise<string> {
 	if (!(GJC_SUBSKILL_PARENT_AGENTS as readonly string[]).includes(input.agentName)) return "";
 
+	const resolvedSessionId = await resolveBoundarySessionId(input.cwd, input.sessionId);
+	if (!resolvedSessionId) return "";
 	const entries = await readActiveSubskillsForParent({
 		cwd: input.cwd,
-		sessionId: input.sessionId,
+		sessionId: resolvedSessionId,
 		parent: input.agentName,
 		phase: "prompt",
 	});

package/src/extensibility/gjc-plugins/state.ts

@@ -1,3 +1,16 @@
+import { resolveGjcSessionForRead, SessionResolutionError } from "../../gjc-runtime/session-resolution";
+
+async function resolveBoundarySessionId(cwd: string, sessionId?: string): Promise<string | undefined> {
+	const normalizedSessionId = sessionId?.trim();
+	if (normalizedSessionId) return normalizedSessionId;
+	try {
+		return (await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID })).gjcSessionId;
+	} catch (error) {
+		if (error instanceof SessionResolutionError && error.code === "no_session") return undefined;
+		throw error;
+	}
+}
+
 import type { ActiveSubskillEntry } from "../../skill-state/active-state";
 import { readVisibleSkillActiveState } from "../../skill-state/active-state";
 import type { LoadedSubskillActivation } from "./types";
@@ -21,7 +34,9 @@ export async function readActiveSubskillsForParent(input: {
 	parent: string;
 	phase: string;
 }): Promise<ActiveSubskillEntry[]> {
-	const state = await readVisibleSkillActiveState(input.cwd, input.sessionId);
+	const resolvedSessionId = await resolveBoundarySessionId(input.cwd, input.sessionId);
+	if (!resolvedSessionId) return [];
+	const state = await readVisibleSkillActiveState(input.cwd, resolvedSessionId);
 	const parent = input.parent.trim();
 	const phase = input.phase.trim();
 	if (!state || !parent || !phase) return [];

package/src/gjc-runtime/deep-interview-recorder.ts

@@ -11,7 +11,8 @@ import {
 	normalizeDeepInterviewEnvelope,
 	questionHash,
 } from "./deep-interview-state";
-import { readExistingStateForMutation, writeWorkflowEnvelopeAtomic } from "./state-writer";
+import { writeSessionActivityMarker } from "./session-resolution";
+import { readExistingStateForMutation, writeGuardedWorkflowEnvelopeAtomic } from "./state-writer";
 
 export * from "./deep-interview-state";
 
@@ -298,6 +299,12 @@ async function readEnvelope(statePath: string): Promise<DeepInterviewStateEnvelo
 	return ensureDeepInterviewStateShape(undefined);
 }
 
+function existingStateRevision(value: unknown): number | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const revision = (value as Record<string, unknown>).state_revision;
+	return typeof revision === "number" && Number.isFinite(revision) ? revision : 0;
+}
+
 function interviewIdOf(envelope: DeepInterviewStateEnvelope): string | undefined {
 	const inner = (envelope.state ?? {}) as Record<string, unknown>;
 	return typeof inner.interview_id === "string" ? inner.interview_id : undefined;
@@ -310,6 +317,7 @@ async function persistEnvelope(
 	sessionId: string | undefined,
 	command: string,
 ): Promise<void> {
+	if (!sessionId) throw new Error("deep-interview recorder requires a session id");
 	const now = new Date().toISOString();
 	const payload: Record<string, unknown> = { ...normalizeDeepInterviewEnvelope(envelope), updated_at: now };
 	// Guarantee RequiredOnWriteEnvelopeSchema fields for the fresh/absent fallback;
@@ -318,11 +326,14 @@ async function persistEnvelope(
 	payload.version ??= WORKFLOW_STATE_VERSION;
 	payload.active ??= true;
 	payload.current_phase ??= "interviewing";
-	await writeWorkflowEnvelopeAtomic(statePath, payload, {
+	await writeGuardedWorkflowEnvelopeAtomic(statePath, payload, {
 		cwd,
+		policy: "source",
+		expectedRevision: existingStateRevision(envelope),
 		receipt: { cwd, skill: "deep-interview", owner: "gjc-runtime", command, sessionId, nowIso: now },
-		audit: { category: "state", verb: "write", owner: "gjc-runtime", skill: "deep-interview" },
+		audit: { category: "state", verb: "write", owner: "gjc-runtime", skill: "deep-interview", sessionId },
 	});
+	await writeSessionActivityMarker(cwd, sessionId, { writer: "deep-interview-recorder", path: statePath });
 }
 
 /**
@@ -335,20 +346,17 @@ async function syncRecorderHud(
 	envelope: DeepInterviewStateEnvelope,
 	sessionId: string | undefined,
 ): Promise<void> {
-	try {
-		const phase = typeof envelope.current_phase === "string" ? envelope.current_phase : "interviewing";
-		await syncSkillActiveState({
-			cwd,
-			skill: "deep-interview",
-			active: phase !== "complete",
-			phase,
-			sessionId,
-			source: "gjc-runtime-deep-interview-recorder",
-			hud: deriveDeepInterviewHud(envelope as Record<string, unknown>, { phase }),
-		});
-	} catch {
-		// HUD sync is best-effort cache maintenance and must not change record semantics.
-	}
+	const phase = typeof envelope.current_phase === "string" ? envelope.current_phase : "interviewing";
+	await syncSkillActiveState({
+		cwd,
+		skill: "deep-interview",
+		active: phase !== "complete",
+		phase,
+		sessionId,
+		source: "gjc-runtime-deep-interview-recorder",
+		hud: deriveDeepInterviewHud(envelope as Record<string, unknown>, { phase }),
+		sourceRevision: existingStateRevision(envelope),
+	});
 }
 
 /**
@@ -360,6 +368,19 @@ async function repairRecorderHudFromPersisted(
 	cwd: string,
 	statePath: string,
 	sessionId: string | undefined,
+): Promise<void> {
+	try {
+		await syncDeepInterviewRecorderHud(cwd, statePath, sessionId);
+	} catch {
+		// HUD sync is best-effort cache maintenance and must not change record semantics.
+	}
+}
+
+/** Refresh the best-effort HUD cache from persisted deep-interview state. */
+export async function syncDeepInterviewRecorderHud(
+	cwd: string,
+	statePath: string,
+	sessionId: string | undefined,
 ): Promise<void> {
 	const read = await readExistingStateForMutation(statePath);
 	if (read.kind !== "valid") return;
@@ -384,7 +405,11 @@ export async function appendOrMergeDeepInterviewRound(
 	}
 	(envelope.state as Record<string, unknown>).rounds = result.rounds;
 	await persistEnvelope(cwd, statePath, envelope, options.sessionId, "gjc deep-interview record-answer");
-	await syncRecorderHud(cwd, envelope, options.sessionId);
+	try {
+		await syncRecorderHud(cwd, envelope, options.sessionId);
+	} catch {
+		// HUD sync is best-effort cache maintenance and must not change record semantics.
+	}
 	return { action: result.action, record: result.record };
 }
 

package/src/gjc-runtime/deep-interview-runtime.ts

@@ -7,6 +7,8 @@ import { deriveDeepInterviewHud } from "../skill-state/workflow-hud";
 import { WORKFLOW_STATE_VERSION } from "../skill-state/workflow-state-contract";
 import { normalizeDeepInterviewEnvelope } from "./deep-interview-state";
 import { runNativeRalplanCommand } from "./ralplan-runtime";
+import { modeStatePath, sessionSpecsDir } from "./session-layout";
+import { resolveGjcSessionForWrite, writeSessionActivityMarker } from "./session-resolution";
 import { runNativeStateCommand } from "./state-runtime";
 import { appendJsonl, readExistingStateForMutation, writeArtifact, writeWorkflowEnvelopeAtomic } from "./state-writer";
 
@@ -76,10 +78,6 @@ function assertSafePathComponent(value: string, label: string): void {
 	}
 }
 
-function encodeSessionSegment(value: string): string {
-	return encodeURIComponent(value).replaceAll(".", "%2E");
-}
-
 function defaultSpecSlug(now: Date = new Date()): string {
 	const yyyy = now.getUTCFullYear().toString().padStart(4, "0");
 	const mm = (now.getUTCMonth() + 1).toString().padStart(2, "0");
@@ -89,14 +87,10 @@ function defaultSpecSlug(now: Date = new Date()): string {
 	return `${yyyy}-${mm}-${dd}-${hh}${min}-${randomBytes(2).toString("hex")}`;
 }
 
-function stateDirFor(cwd: string, sessionId: string | undefined): string {
-	return sessionId
-		? path.join(cwd, ".gjc", "state", "sessions", encodeSessionSegment(sessionId))
-		: path.join(cwd, ".gjc", "state");
-}
-
-export function deepInterviewStatePath(cwd: string, sessionId: string | undefined): string {
-	return path.join(stateDirFor(cwd, sessionId), "deep-interview-state.json");
+export function deepInterviewStatePath(cwd: string, sessionId?: string): string {
+	const resolvedSessionId = sessionId?.trim() || process.env.GJC_SESSION_ID?.trim();
+	if (!resolvedSessionId) throw new Error("deep-interview state path requires a session id");
+	return modeStatePath(cwd, resolvedSessionId, "deep-interview");
 }
 
 async function resolveSpecContent(rawSpec: string, cwd: string): Promise<string> {
@@ -117,7 +111,7 @@ interface ResolvedDeepInterviewArgs {
 	resolution: DeepInterviewResolution;
 	threshold: number;
 	thresholdSource: string;
-	sessionId?: string;
+	sessionId: string;
 	idea: string;
 	language?: DeepInterviewLanguagePreference;
 	json: boolean;
@@ -134,7 +128,7 @@ export interface ResolvedDeepInterviewSpecWriteArgs {
 	stage: "final";
 	slug: string;
 	spec: string;
-	sessionId?: string;
+	sessionId: string;
 	json: boolean;
 	deliberate: boolean;
 	handoff?: "ralplan";
@@ -277,8 +271,12 @@ async function resolveSpecWriteArgs(args: readonly string[], cwd: string): Promi
 		throw new DeepInterviewCommandError(2, "--spec is required for deep-interview --write");
 	}
 
-	const sessionId = flagValue(args, "--session-id")?.trim() || undefined;
-	if (sessionId) assertSafePathComponent(sessionId, "session-id");
+	const session = resolveGjcSessionForWrite(cwd, {
+		flagValue: flagValue(args, "--session-id"),
+		envSessionId: process.env.GJC_SESSION_ID,
+	});
+	const sessionId = session.gjcSessionId;
+	assertSafePathComponent(sessionId, "session-id");
 
 	const rawHandoff = flagValue(args, "--handoff")?.trim() || undefined;
 	if (rawHandoff && rawHandoff !== "ralplan") {
@@ -324,8 +322,12 @@ async function resolveSpecWriteArgs(args: readonly string[], cwd: string): Promi
 }
 
 async function resolveDeepInterviewArgs(args: readonly string[], cwd: string): Promise<ResolvedDeepInterviewArgs> {
-	const sessionId = flagValue(args, "--session-id")?.trim() || undefined;
-	if (sessionId) assertSafePathComponent(sessionId, "session-id");
+	const session = resolveGjcSessionForWrite(cwd, {
+		flagValue: flagValue(args, "--session-id"),
+		envSessionId: process.env.GJC_SESSION_ID,
+	});
+	const sessionId = session.gjcSessionId;
+	assertSafePathComponent(sessionId, "session-id");
 
 	const explicitResolutions = (["quick", "standard", "deep"] as const).filter(name => hasFlag(args, `--${name}`));
 	if (explicitResolutions.length > 1) {
@@ -402,19 +404,34 @@ export async function persistDeepInterviewSpec(
 	}
 	const existing = existingRead.kind === "valid" ? existingRead.value : {};
 
-	const specPath = path.join(cwd, ".gjc", "specs", `deep-interview-${resolved.slug}.md`);
+	const specPath = path.join(sessionSpecsDir(cwd, resolved.sessionId), `deep-interview-${resolved.slug}.md`);
 	const content = resolved.spec.endsWith("\n") ? resolved.spec : `${resolved.spec}\n`;
 	await writeArtifact(specPath, content, {
 		cwd,
-		audit: { category: "artifact", verb: "write", owner: "gjc-runtime", skill: "deep-interview" },
+		audit: {
+			category: "artifact",
+			verb: "write",
+			owner: "gjc-runtime",
+			skill: "deep-interview",
+			sessionId: resolved.sessionId,
+		},
 	});
 
 	const sha256 = createHash("sha256").update(content).digest("hex");
 	const createdAt = new Date().toISOString();
 	await appendJsonl(
-		path.join(cwd, ".gjc", "specs", "deep-interview-index.jsonl"),
+		path.join(sessionSpecsDir(cwd, resolved.sessionId), "deep-interview-index.jsonl"),
 		{ slug: resolved.slug, stage: resolved.stage, path: specPath, created_at: createdAt, sha256 },
-		{ cwd, audit: { category: "ledger", verb: "append", owner: "gjc-runtime", skill: "deep-interview" } },
+		{
+			cwd,
+			audit: {
+				category: "ledger",
+				verb: "append",
+				owner: "gjc-runtime",
+				skill: "deep-interview",
+				sessionId: resolved.sessionId,
+			},
+		},
 	);
 
 	const payload = normalizeDeepInterviewEnvelope({
@@ -446,9 +463,11 @@ export async function persistDeepInterviewSpec(
 			verb: "write",
 			owner: "gjc-runtime",
 			skill: "deep-interview",
+			sessionId: resolved.sessionId,
 			forced: resolved.force,
 		},
 	});
+	await writeSessionActivityMarker(cwd, resolved.sessionId, { writer: "deep-interview-runtime", path: statePath });
 	await syncDeepInterviewHud({
 		cwd,
 		sessionId: resolved.sessionId,
@@ -503,8 +522,15 @@ async function seedDeepInterviewState(cwd: string, resolved: ResolvedDeepIntervi
 			sessionId: resolved.sessionId,
 			nowIso: now,
 		},
-		audit: { category: "state", verb: "write", owner: "gjc-runtime", skill: "deep-interview" },
+		audit: {
+			category: "state",
+			verb: "write",
+			owner: "gjc-runtime",
+			skill: "deep-interview",
+			sessionId: resolved.sessionId,
+		},
 	});
+	await writeSessionActivityMarker(cwd, resolved.sessionId, { writer: "deep-interview-runtime", path: statePath });
 	await syncDeepInterviewHud({ cwd, sessionId: resolved.sessionId, payload, phase: "interviewing" });
 	return statePath;
 }

package/src/gjc-runtime/goal-mode-request.ts

@@ -8,6 +8,8 @@ import {
 	type ModeChangeEntry,
 	type SessionEntry,
 } from "../session/session-manager";
+import { sessionStateDir, sessionUltragoalDir } from "./session-layout";
+import { resolveGjcSessionForRead, resolveGjcSessionForWrite, writeSessionActivityMarker } from "./session-resolution";
 import { removeFileAudited, writeJsonAtomic } from "./state-writer";
 
 export const GJC_SESSION_FILE_ENV = "GJC_SESSION_FILE";
@@ -48,12 +50,12 @@ function isEnoent(error: unknown): boolean {
 	);
 }
 
-function requestPath(cwd: string): string {
-	return path.join(cwd, ".gjc", "state", "goal-mode-request.json");
+function requestPath(cwd: string, sessionId: string): string {
+	return path.join(sessionStateDir(cwd, sessionId), "goal-mode-request.json");
 }
 
-function ultragoalGoalsPath(cwd: string): string {
-	return path.join(cwd, ".gjc", "ultragoal", "goals.json");
+function ultragoalGoalsPath(cwd: string, sessionId: string): string {
+	return path.join(sessionUltragoalDir(cwd, sessionId), "goals.json");
 }
 
 function isCreateGoalsArg(value: string): boolean {
@@ -65,8 +67,14 @@ export function isUltragoalCreateGoalsInvocation(args: readonly string[]): boole
 	return command !== undefined && isCreateGoalsArg(command);
 }
 
-export async function readUltragoalGjcObjective(cwd: string): Promise<{ objective: string; goalsPath: string }> {
-	const goalsPath = ultragoalGoalsPath(cwd);
+export async function readUltragoalGjcObjective(
+	cwd: string,
+	sessionId?: string | null,
+): Promise<{ objective: string; goalsPath: string }> {
+	const session = sessionId?.trim()
+		? { gjcSessionId: sessionId.trim() }
+		: await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID });
+	const goalsPath = ultragoalGoalsPath(cwd, session.gjcSessionId);
 	try {
 		const plan = (await Bun.file(goalsPath).json()) as UltragoalPlanShape;
 		const objective = typeof plan.gjcObjective === "string" ? plan.gjcObjective.trim() : "";
@@ -87,7 +95,10 @@ export async function writePendingGoalModeRequest(input: {
 }): Promise<PendingGoalModeRequest> {
 	const objective = input.objective.trim();
 	if (!objective) throw new Error("goal objective is required");
-	const sessionId = input.sessionId?.trim();
+	const resolvedSessionId =
+		input.sessionId?.trim() ||
+		resolveGjcSessionForWrite(input.cwd, { envSessionId: process.env.GJC_SESSION_ID }).gjcSessionId;
+	const sessionId = resolvedSessionId;
 	const request: PendingGoalModeRequest = {
 		version: REQUEST_VERSION,
 		kind: "goal_mode_request",
@@ -97,11 +108,12 @@ export async function writePendingGoalModeRequest(input: {
 		goalsPath: input.goalsPath,
 		...(sessionId ? { sessionId } : {}),
 	};
-	const filePath = requestPath(input.cwd);
+	const filePath = requestPath(input.cwd, sessionId);
 	await writeJsonAtomic(filePath, request, {
 		cwd: input.cwd,
-		audit: { category: "state", verb: "write", owner: "gjc-runtime" },
+		audit: { category: "state", verb: "write", owner: "gjc-runtime", sessionId },
 	});
+	await writeSessionActivityMarker(input.cwd, sessionId, { writer: "goal-mode-request", path: filePath });
 	return request;
 }
 
@@ -175,7 +187,10 @@ export async function consumePendingGoalModeRequest(
 	cwd: string,
 	currentSessionId?: string | null,
 ): Promise<PendingGoalModeRequest | null> {
-	const filePath = requestPath(cwd);
+	const session = currentSessionId?.trim()
+		? { gjcSessionId: currentSessionId.trim() }
+		: await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID });
+	const filePath = requestPath(cwd, session.gjcSessionId);
 	let raw: unknown;
 	try {
 		raw = await Bun.file(filePath).json();
@@ -203,7 +218,7 @@ export async function consumePendingGoalModeRequest(
 	}
 	await removeFileAudited(filePath, {
 		cwd,
-		audit: { category: "prune", verb: "remove", owner: "gjc-runtime" },
+		audit: { category: "prune", verb: "remove", owner: "gjc-runtime", sessionId: session.gjcSessionId },
 	}).catch(error => {
 		if (!isEnoent(error)) throw error;
 	});

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

@@ -2,6 +2,7 @@ import { Buffer } from "node:buffer";
 import * as path from "node:path";
 import { safeStderrWrite } from "@gajae-code/utils";
 import type { Args } from "../cli/args";
+import { tmuxRuntimeSessionPath } from "./session-layout";
 import { GJC_COORDINATOR_SESSION_ID_ENV, GJC_COORDINATOR_SESSION_STATE_FILE_ENV } from "./session-state-sidecar";
 import {
 	buildGjcTmuxProfileCommands,
@@ -360,9 +361,13 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 	const sessionName = buildGjcTmuxSessionName(env, { branch });
 	const tmuxCommand = resolveGjcTmuxCommand(env);
 	const sessionId = env[GJC_COORDINATOR_SESSION_ID_ENV]?.trim() || sessionName;
+	// The session ROOT is keyed by the active GJC session (GJC_SESSION_ID), NOT the
+	// coordinator/tmux identity. Fall back to the coordinator id only for standalone
+	// tmux launches with no GJC session context.
+	const gjcSessionId = env.GJC_SESSION_ID?.trim() || sessionId;
 	const sessionStateFile =
 		env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim() ||
-		path.join(cwd, ".gjc", "runtime", "tmux-sessions", `${buildGjcTmuxSessionSlug(sessionName)}.json`);
+		tmuxRuntimeSessionPath(cwd, gjcSessionId, buildGjcTmuxSessionSlug(sessionName));
 	const tmuxAvailable = context.tmuxAvailable ?? Bun.which(tmuxCommand) !== null;
 	if (!tmuxAvailable) return undefined;
 	const existingSessionName =