@gajae-code/coding-agent 0.6.4 → 0.7.0

package/src/skill-state/active-state.ts

@@ -1,4 +1,6 @@
-import * as path from "node:path";
+import * as logger from "@gajae-code/utils/logger";
+import { activeSnapshotPath, assertNonEmptyGjcSessionId, modeStatePath } from "../gjc-runtime/session-layout";
+import { resolveGjcSessionForRead, SessionResolutionError } from "../gjc-runtime/session-resolution";
 import {
 	type ActiveSessionScope,
 	readActiveEntries,
@@ -6,13 +8,12 @@ import {
 	removeActiveEntry,
 	writeActiveEntry,
 } from "../gjc-runtime/state-writer";
+import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill } from "./canonical-skills";
 import type { WorkflowStateReceipt } from "./workflow-state-contract";
 
 export const SKILL_ACTIVE_STATE_FILE = "skill-active-state.json";
 
-export const CANONICAL_GJC_WORKFLOW_SKILLS = ["deep-interview", "ralplan", "ultragoal", "team"] as const;
-
-export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];
+export { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill };
 export type WorkflowHudSeverity = "info" | "warning" | "blocked" | "error" | "success";
 
 export interface WorkflowHudChip {
@@ -60,6 +61,7 @@ export interface SkillActiveEntry {
 	handoff_to?: string;
 	handoff_at?: string;
 	active_subskills?: ActiveSubskillEntry[];
+	source_state_revision?: number;
 }
 
 export interface SkillActiveState {
@@ -83,7 +85,7 @@ export interface SkillActiveState {
 
 export interface SkillActiveStatePaths {
 	rootPath: string;
-	sessionPath?: string;
+	sessionPath: string;
 }
 
 export interface SyncSkillActiveStateOptions {
@@ -102,6 +104,7 @@ export interface SyncSkillActiveStateOptions {
 	handoff_to?: string;
 	handoff_at?: string;
 	active_subskills?: ActiveSubskillEntry[];
+	sourceRevision?: number;
 }
 
 const HUD_TEXT_LIMIT = 80;
@@ -246,8 +249,12 @@ function unionActiveSubskillEntries(...entrySets: Array<ActiveSubskillEntry[] |
 	return merged;
 }
 
-function encodePathSegment(value: string): string {
-	return encodeURIComponent(value).replaceAll(".", "%2E");
+function resolveBoundarySessionId(cwd: string, sessionId?: string): Promise<string> {
+	const normalizedSessionId = safeString(sessionId).trim();
+	if (normalizedSessionId) return Promise.resolve(normalizedSessionId);
+	return resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID }).then(
+		context => context.gjcSessionId,
+	);
 }
 
 function entryKey(entry: Pick<SkillActiveEntry, "skill" | "session_id">): string {
@@ -343,14 +350,10 @@ export function normalizeSkillActiveState(raw: unknown): SkillActiveState | null
 }
 
 export function getSkillActiveStatePaths(cwd: string, sessionId?: string): SkillActiveStatePaths {
-	const stateDir = path.join(cwd, ".gjc", "state");
-	const rootPath = path.join(stateDir, SKILL_ACTIVE_STATE_FILE);
 	const normalizedSessionId = safeString(sessionId).trim();
-	if (!normalizedSessionId) return { rootPath };
-	return {
-		rootPath,
-		sessionPath: path.join(stateDir, "sessions", encodePathSegment(normalizedSessionId), SKILL_ACTIVE_STATE_FILE),
-	};
+	assertNonEmptyGjcSessionId(normalizedSessionId, "getSkillActiveStatePaths");
+	const sessionPath = activeSnapshotPath(cwd, normalizedSessionId);
+	return { rootPath: sessionPath, sessionPath };
 }
 
 /**
@@ -380,7 +383,12 @@ async function readRawActiveStateForHandoff(filePath: string, strict: boolean):
 		if (!parsed || typeof parsed !== "object") return null;
 		return parsed as SkillActiveState;
 	} catch (err) {
-		if (!strict) return null;
+		if (!strict) {
+			logger.warn(
+				`gjc skill-state: invalid skill-active-state at ${filePath}: invalid JSON: ${(err as Error).message}`,
+			);
+			return null;
+		}
 		throw err;
 	}
 }
@@ -419,14 +427,10 @@ function rawActiveEntries(state: SkillActiveState | null): SkillActiveEntry[] {
 
 async function readModeStatePhase(
 	cwd: string,
-	sessionId: string | undefined,
+	sessionId: string,
 	skill: CanonicalGjcWorkflowSkill,
 ): Promise<string | undefined> {
-	const stateDir = path.join(cwd, ".gjc", "state");
-	const normalizedSessionId = safeString(sessionId).trim();
-	const filePath = normalizedSessionId
-		? path.join(stateDir, "sessions", encodePathSegment(normalizedSessionId), `${skill}-state.json`)
-		: path.join(stateDir, `${skill}-state.json`);
+	const filePath = modeStatePath(cwd, sessionId, skill);
 	try {
 		const parsed = JSON.parse(await Bun.file(filePath).text());
 		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
@@ -473,15 +477,6 @@ function withCanonicalRalplanPhase(entry: SkillActiveEntry, canonicalPhase: stri
 	};
 }
 
-function filterRootEntriesForSession(entries: SkillActiveEntry[], sessionId?: string): SkillActiveEntry[] {
-	const normalizedSessionId = safeString(sessionId).trim();
-	if (!normalizedSessionId) return entries;
-	return entries.filter(entry => {
-		const entrySessionId = safeString(entry.session_id).trim();
-		return entrySessionId.length === 0 || entrySessionId === normalizedSessionId;
-	});
-}
-
 function entryRecency(entry: SkillActiveEntry): number {
 	const stamp = entry.handoff_at || entry.updated_at || entry.activated_at;
 	const ms = stamp ? Date.parse(stamp) : Number.NaN;
@@ -603,57 +598,50 @@ export function collapsePlanningPipeline(entries: readonly SkillActiveEntry[]):
 async function mergeVisibleEntries(
 	cwd: string,
 	sessionState: SkillActiveState | null,
-	rootState: SkillActiveState | null,
-	sessionId?: string,
+	sessionId: string,
 ): Promise<SkillActiveEntry[]> {
 	// Use the raw (active + inactive) rows so a handoff demotion stays visible
 	// long enough to supersede a stale same-skill row before the active filter.
 	// Per-skill files in active/<skill>.json are authoritative and are merged
 	// after the derived snapshot cache, so a stale skill-active-state.json row
 	// cannot override the latest entry file.
-	const rootEntries = filterRootEntriesForSession(
-		[...rawActiveEntries(rootState), ...(await readActiveEntries(cwd))],
-		sessionId,
-	);
-	const merged = new Map(rootEntries.map(entry => [entryKey(entry), entry]));
-	const sessionEntries = sessionId
-		? [...rawActiveEntries(sessionState), ...(await readActiveEntries(cwd, { sessionId }))]
-		: rawActiveEntries(sessionState);
-	for (const entry of sessionEntries) {
-		merged.set(entryKey(entry), entry);
-	}
+	const entries = [...rawActiveEntries(sessionState), ...(await readActiveEntries(cwd, { sessionId }))];
+	const merged = new Map(entries.map(entry => [entryKey(entry), entry]));
 	const canonicalRalplanPhase = await readModeStatePhase(cwd, sessionId, "ralplan");
-	return collapsePlanningPipeline(
-		dedupeVisibleBySkill([...merged.values()], sessionId)
-			.filter(entry => entry.active !== false)
-			.map(entry => withCanonicalRalplanPhase(entry, canonicalRalplanPhase)),
-	);
+	const visibleEntries = dedupeVisibleBySkill([...merged.values()], sessionId)
+		.filter(entry => entry.active !== false)
+		.map(entry => withCanonicalRalplanPhase(entry, canonicalRalplanPhase));
+	return collapsePlanningPipeline(visibleEntries).toSorted(comparePipelineEntry);
 }
 
 export async function readVisibleSkillActiveState(cwd: string, sessionId?: string): Promise<SkillActiveState | null> {
-	const { rootPath, sessionPath } = getSkillActiveStatePaths(cwd, sessionId);
-	const [rootState, sessionState] = await Promise.all([
-		readRawActiveStateForHandoff(rootPath, false),
-		sessionPath ? readRawActiveStateForHandoff(sessionPath, false) : Promise.resolve(null),
-	]);
-	const activeSkills = await mergeVisibleEntries(cwd, sessionState, rootState, sessionId);
+	let resolvedSessionId: string;
+	try {
+		resolvedSessionId = await resolveBoundarySessionId(cwd, sessionId);
+	} catch (error) {
+		if (error instanceof SessionResolutionError && error.code === "no_session") return null;
+		throw error;
+	}
+	const { sessionPath } = getSkillActiveStatePaths(cwd, resolvedSessionId);
+	const sessionState = await readRawActiveStateForHandoff(sessionPath, false);
+	const activeSkills = await mergeVisibleEntries(cwd, sessionState, resolvedSessionId);
 	if (activeSkills.length === 0) return null;
 	const primary = activeSkills[0];
 	return {
-		...(rootState ?? {}),
 		...(sessionState ?? {}),
 		version: 1,
 		active: true,
-		skill: primary?.skill ?? "",
-		phase: primary?.phase ?? "",
-		session_id: safeString(sessionId).trim() || primary?.session_id,
+		skill: sessionState?.skill ?? primary?.skill ?? "",
+		phase: sessionState?.phase ?? primary?.phase ?? "",
+		session_id: resolvedSessionId,
 		active_skills: activeSkills,
 		active_subskills: activeSkills.flatMap(entry => entry.active_subskills ?? []),
 	};
 }
 
-function activeStateWriterAudit(verb: string) {
-	return { category: "state" as const, verb, owner: "gjc-runtime" as const };
+function activeStateWriterAudit(verb: string, sessionScope?: ActiveSessionScope | string) {
+	const sessionId = typeof sessionScope === "string" ? sessionScope : sessionScope?.sessionId;
+	return { category: "state" as const, verb, owner: "gjc-runtime" as const, ...(sessionId ? { sessionId } : {}) };
 }
 
 async function persistActiveEntry(
@@ -664,12 +652,13 @@ async function persistActiveEntry(
 	if (entry.active === false) {
 		await removeActiveEntry(cwd, sessionScope, entry.skill, {
 			cwd,
-			audit: activeStateWriterAudit("remove-active-entry"),
+			audit: activeStateWriterAudit("remove-active-entry", sessionScope),
+			sourceRevision: entry.source_state_revision,
 		});
 	} else {
 		await writeActiveEntry(cwd, sessionScope, entry.skill, entry, {
 			cwd,
-			audit: activeStateWriterAudit("write-active-entry"),
+			audit: activeStateWriterAudit("write-active-entry", sessionScope),
 		});
 	}
 }
@@ -681,12 +670,15 @@ async function writeHandoffEntry(
 ): Promise<void> {
 	await writeActiveEntry(cwd, sessionScope, entry.skill, entry, {
 		cwd,
-		audit: activeStateWriterAudit("write-active-entry"),
+		audit: activeStateWriterAudit("write-active-entry", sessionScope),
 	});
 }
 
 async function rebuildActiveState(cwd: string, sessionScope?: ActiveSessionScope): Promise<void> {
-	await rebuildActiveSnapshot(cwd, sessionScope, { cwd, audit: activeStateWriterAudit("rebuild-active-snapshot") });
+	await rebuildActiveSnapshot(cwd, sessionScope, {
+		cwd,
+		audit: activeStateWriterAudit("rebuild-active-snapshot", sessionScope),
+	});
 }
 
 async function removeSupersededPlanningPipelineEntries(
@@ -698,7 +690,7 @@ async function removeSupersededPlanningPipelineEntries(
 	for (const skill of upstreamPlanningPipelineSkills(entry.skill)) {
 		await removeActiveEntry(cwd, sessionScope, skill, {
 			cwd,
-			audit: activeStateWriterAudit("remove-superseded-pipeline-entry"),
+			audit: activeStateWriterAudit("remove-superseded-pipeline-entry", sessionScope),
 		});
 	}
 }
@@ -708,18 +700,17 @@ async function activeSubskillsForExistingEntry(
 	sessionId: string | undefined,
 	skill: string,
 ): Promise<ActiveSubskillEntry[] | undefined> {
-	const { rootPath, sessionPath } = getSkillActiveStatePaths(cwd, sessionId);
-	const [rootState, sessionState] = await Promise.all([
-		readRawActiveStateForHandoff(rootPath, false),
-		sessionPath ? readRawActiveStateForHandoff(sessionPath, false) : Promise.resolve(null),
-	]);
-	const existing = (await mergeVisibleEntries(cwd, sessionState, rootState, sessionId)).find(
+	const resolvedSessionId = await resolveBoundarySessionId(cwd, sessionId);
+	const { sessionPath } = getSkillActiveStatePaths(cwd, resolvedSessionId);
+	const sessionState = await readRawActiveStateForHandoff(sessionPath, false);
+	const existing = (await mergeVisibleEntries(cwd, sessionState, resolvedSessionId)).find(
 		entry => entry.skill === skill,
 	);
 	return existing?.active_subskills;
 }
 
 export async function syncSkillActiveState(options: SyncSkillActiveStateOptions): Promise<void> {
+	if (!options.sessionId) return;
 	const preservedActiveSubskills =
 		options.active_subskills === undefined
 			? await activeSubskillsForExistingEntry(options.cwd, options.sessionId, options.skill)
@@ -745,12 +736,8 @@ export async function syncSkillActiveState(options: SyncSkillActiveStateOptions)
 			: preservedActiveSubskills
 				? { active_subskills: preservedActiveSubskills }
 				: {}),
+		...(typeof options.sourceRevision === "number" ? { source_state_revision: options.sourceRevision } : {}),
 	};
-	await removeSupersededPlanningPipelineEntries(options.cwd, undefined, entry);
-	await persistActiveEntry(options.cwd, undefined, entry);
-	await rebuildActiveState(options.cwd);
-
-	if (!options.sessionId) return;
 	const sessionScope = { sessionId: options.sessionId };
 	await removeSupersededPlanningPipelineEntries(options.cwd, sessionScope, entry);
 	await persistActiveEntry(options.cwd, sessionScope, entry);
@@ -768,36 +755,23 @@ export interface ApplyHandoffOptions {
 }
 
 /**
- * Atomically apply a workflow-skill handoff to both the session-scoped and
- * root `skill-active-state.json` files in a single write per file.
- *
- * Write order: **session first, root last**. The session file is the
- * source of truth for HUD; the root aggregate must never lead the session
- * during a handoff window. Each file is rewritten once with caller demoted
- * to `active:false` (preserving `handoff_to`/`handoff_at` lineage) and
- * callee promoted to `active:true` (with `handoff_from`/`handoff_at`).
+ * Atomically apply a workflow-skill handoff to the session-scoped active state.
  */
 export async function applyHandoffToActiveState(options: ApplyHandoffOptions): Promise<void> {
 	const nowIso = options.nowIso ?? new Date().toISOString();
 	const callerEntry = buildSyncEntry(options.caller, nowIso);
 	const calleeEntry = buildSyncEntry(options.callee, nowIso);
 	const sessionId = options.callee.sessionId ?? options.caller.sessionId;
-	const { rootPath, sessionPath } = getSkillActiveStatePaths(options.cwd, sessionId);
+	assertNonEmptyGjcSessionId(sessionId, "applyHandoffToActiveState");
+	const { sessionPath } = getSkillActiveStatePaths(options.cwd, sessionId);
 	const readState = (filePath: string) => readRawActiveStateForHandoff(filePath, options.strict === true);
-	await Promise.all([readState(rootPath), ...(sessionPath ? [readState(sessionPath)] : [])]);
-
-	// A skill can hold more than one visible row in this session's scope — e.g.
-	// it was seeded without a session id (rendered globally) and is now handed
-	// off under a concrete session id. Supersede every same-session-scope row of
-	// the caller and callee skills, not just the exact `skill::session_id` key,
-	// so a stale `active:true` row cannot survive the demotion and keep showing
-	// in the HUD. Rows owned by other sessions are left untouched.
+	await readState(sessionPath);
+
 	const handoffSession = safeString(sessionId).trim();
 	const reassignedSkills = new Set([callerEntry.skill, calleeEntry.skill]);
 	const supersedesVisible = (entry: SkillActiveEntry): boolean => {
 		if (!reassignedSkills.has(entry.skill)) return false;
-		const entrySession = safeString(entry.session_id).trim();
-		return entrySession.length === 0 || entrySession === handoffSession;
+		return safeString(entry.session_id).trim() === handoffSession;
 	};
 	const applyEntries = (entries: SkillActiveEntry[]): SkillActiveEntry[] => {
 		const callerKey = entryKey(callerEntry);
@@ -805,9 +779,6 @@ export async function applyHandoffToActiveState(options: ApplyHandoffOptions): P
 			entries.find(e => entryKey(e) === callerKey) ??
 			entries.find(e => e.skill === callerEntry.skill && supersedesVisible(e) && Boolean(e.handoff_from));
 		const kept = entries.filter(e => !supersedesVisible(e));
-		// Merge prior lineage into the demoted caller so multi-step handoff
-		// chains preserve `handoff_from` from the previous transition while
-		// the new `handoff_to`/`handoff_at` describe this one.
 		const mergedCaller: SkillActiveEntry = priorCaller
 			? {
 					...callerEntry,
@@ -822,10 +793,7 @@ export async function applyHandoffToActiveState(options: ApplyHandoffOptions): P
 			activeSubskills.length > 0 ? { ...calleeEntry, active_subskills: activeSubskills } : calleeEntry;
 		return [...kept, mergedCaller, mergedCallee];
 	};
-	const writeEntries = async (
-		sessionScope: ActiveSessionScope | undefined,
-		prior: SkillActiveState | null,
-	): Promise<void> => {
+	const writeEntries = async (sessionScope: ActiveSessionScope, prior: SkillActiveState | null): Promise<void> => {
 		const nextEntries = applyEntries(rawActiveEntries(prior));
 		for (const entry of nextEntries) {
 			await writeHandoffEntry(options.cwd, sessionScope, entry);
@@ -833,12 +801,8 @@ export async function applyHandoffToActiveState(options: ApplyHandoffOptions): P
 		await rebuildActiveState(options.cwd, sessionScope);
 	};
 
-	if (sessionPath) {
-		const prior = await readState(sessionPath);
-		await writeEntries({ sessionId }, prior);
-	}
-	const priorRoot = await readState(rootPath);
-	await writeEntries(undefined, priorRoot);
+	const prior = await readState(sessionPath);
+	await writeEntries({ sessionId }, prior);
 }
 
 function buildSyncEntry(options: SyncSkillActiveStateOptions, nowIso: string): SkillActiveEntry {

package/src/skill-state/canonical-skills.ts

@@ -0,0 +1,4 @@
+/** Native-free canonical GJC workflow skill identifiers. */
+export const CANONICAL_GJC_WORKFLOW_SKILLS = ["deep-interview", "ralplan", "ultragoal", "team"] as const;
+
+export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];

package/src/skill-state/deep-interview-mutation-guard.ts

@@ -4,6 +4,8 @@ import * as path from "node:path";
 import type { AgentTool } from "@gajae-code/agent-core";
 import { logger } from "@gajae-code/utils";
 import { expandApplyPatchToEntries } from "../edit/modes/apply-patch";
+import { GJC_SESSION_PREFIX, modeStatePath as sessionModeStatePath } from "../gjc-runtime/session-layout";
+import { resolveGjcSessionForRead } from "../gjc-runtime/session-resolution";
 import { ModeStateSchema } from "../gjc-runtime/state-schema";
 import { LocalProtocolHandler, resolveLocalUrlToPath } from "../internal-urls/local-protocol";
 import { resolveToCwd } from "../tools/path-utils";
@@ -31,27 +33,10 @@ function planningPhaseBlockMessage(skill: CanonicalGjcWorkflowSkill): string {
 	return DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE;
 }
 
-const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit", "bash"]);
+const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit"]);
 const ARCHIVE_OR_SQLITE_BASE_RE = /^(.+?\.(?:tar\.gz|sqlite3|sqlite|db3|zip|tgz|tar|db))(?:$|:)/i;
 const INTERNAL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
 const VIM_FILE_SWITCH_RE = /^\s*:(?:e|e!|edit|edit!)(?:\s+([^<\r\n]+))?(?:<CR>|\r|\n|$)/i;
-const BASH_TOKEN_RE = /'[^']*'|"(?:\\.|[^"\\])*"|\S+/g;
-const BASH_REDIRECT_RE = /^(?:\d*)>>?$/;
-const BASH_HEREDOC_RE = /^(?:\d*)<<-?$/;
-// Shell command-list / redirection / substitution operators. Includes `\r` and
-// `\n` because the shell treats a newline as a command separator and tool command
-// strings can be multiline (e.g. heredocs).
-const BASH_CONTROL_OPERATOR_RE = /[;&|<>`\r\n]|\$\(/;
-// Best-effort, defense-in-depth bash mutation detection. The authoritative
-// planning-phase guard is the dedicated `write`/`edit`/`ast_edit` tools (fully
-// pathed); this catches the common shell mutators plus all redirect targets so a
-// cooperative agent cannot trivially side-step those tools. It is deliberately
-// NOT exhaustive: arbitrary interpreters (`python -c`, `node -e`) and the
-// `key=value` operand forms of utilities like `dd of=` are not parsed, and path
-// classification is lexical (no realpath), matching the rest of this guard and
-// the broader `.gjc` path handling. Hardening any of these would require a real
-// shell parser / symlink resolution and is out of scope for the planning rails.
-const BASH_MUTATION_COMMANDS = new Set(["rm", "mv", "cp", "touch", "mkdir", "ln", "tee"]);
 
 type ToolWithEditMode = AgentTool & {
 	mode?: unknown;
@@ -93,15 +78,18 @@ function safeString(value: unknown): string {
 	return typeof value === "string" ? value : "";
 }
 
-function encodePathSegment(value: string): string {
-	return encodeURIComponent(value).replaceAll(".", "%2E");
+async function resolveBoundarySessionId(cwd: string, sessionId?: string): Promise<string | null> {
+	const normalizedSessionId = sessionId?.trim();
+	if (normalizedSessionId) return normalizedSessionId;
+	try {
+		return (await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID })).gjcSessionId;
+	} catch {
+		return null;
+	}
 }
 
-function modeStatePath(cwd: string, skill: string, sessionId?: string): string {
-	const stateDir = path.join(cwd, ".gjc", "state");
-	const fileName = `${skill}-state.json`;
-	if (sessionId) return path.join(stateDir, "sessions", encodePathSegment(sessionId), fileName);
-	return path.join(stateDir, fileName);
+function modeStatePath(cwd: string, skill: string, sessionId: string): string {
+	return sessionModeStatePath(cwd, sessionId, skill);
 }
 
 function warnInvalidModeState(filePath: string, error: string): void {
@@ -129,12 +117,8 @@ async function readValidatedModeState(filePath: string): Promise<ModeState | nul
 	}
 	return state;
 }
-async function readVisibleModeState(cwd: string, skill: string, sessionId?: string): Promise<ModeState | null> {
-	if (sessionId) {
-		const sessionState = await readValidatedModeState(modeStatePath(cwd, skill, sessionId));
-		if (sessionState) return sessionState;
-	}
-	return await readValidatedModeState(modeStatePath(cwd, skill));
+async function readVisibleModeState(cwd: string, skill: string, sessionId: string): Promise<ModeState | null> {
+	return await readValidatedModeState(modeStatePath(cwd, skill, sessionId));
 }
 
 /**
@@ -228,16 +212,20 @@ async function getActivePlanningSkill(
 	sessionId?: string,
 	threadId?: string,
 ): Promise<ActivePlanningSkill | null> {
-	const skillState = await readVisibleSkillActiveState(cwd, sessionId);
+	const resolvedSessionId = await resolveBoundarySessionId(cwd, sessionId);
+	if (!resolvedSessionId) return null;
+	const skillState = await readVisibleSkillActiveState(cwd, resolvedSessionId);
 	if (!skillState) return null;
-	const activeEntries = listActiveSkills(skillState).filter(entry => entryMatchesContext(entry, sessionId, threadId));
+	const activeEntries = listActiveSkills(skillState).filter(entry =>
+		entryMatchesContext(entry, resolvedSessionId, threadId),
+	);
 	if (activeEntries.length === 0) return null;
 	const current = resolveCurrentWorkflowEntry(activeEntries, safeString(skillState.skill).trim());
 	if (!isPlanningSkill(current.skill)) return null;
-	const modeState = await readVisibleModeState(cwd, current.skill, sessionId);
+	const modeState = await readVisibleModeState(cwd, current.skill, resolvedSessionId);
 	if (!modeState) return null;
 	if (modeState.active !== true) return null;
-	if (!modeStateMatchesContext(modeState, sessionId, threadId)) return null;
+	if (!modeStateMatchesContext(modeState, resolvedSessionId, threadId)) return null;
 	const phase = String(modeState.current_phase ?? current.phase ?? "").trim();
 	if (!isBlockingPlanningPhase(current.skill, phase)) return null;
 	return { skill: current.skill, phase };
@@ -342,81 +330,10 @@ function extractEditTargets(args: unknown, tool: ToolWithEditMode): ExtractedTar
 	return targets;
 }
 
-function extractBashTargets(args: unknown): ExtractedTargets {
-	const record = getRecord(args);
-	const command = safeString(record?.command).trim();
-	const targets: ExtractedTargets = { paths: [], unknown: false };
-	if (!command) {
-		targets.unknown = true;
-		return targets;
-	}
-	// Fast path for a sanctioned `gjc …` invocation, but ONLY when it is a single
-	// command with no shell control operators or redirects. Otherwise a compound
-	// like `gjc … ; tee src/x` or `gjc … > .gjc/state/foo` would skip scanning and
-	// bypass both the planning block and the always-on `.gjc/**` block, so fall
-	// through to full token scanning (which leaves the `gjc` segment's own args
-	// unextracted but still catches the trailing mutation/redirect).
-	if (/^gjc(?:\s|$)/.test(command) && !BASH_CONTROL_OPERATOR_RE.test(command)) return targets;
-
-	const tokens = command.match(BASH_TOKEN_RE)?.map(unquoteBashToken) ?? [];
-	for (let index = 0; index < tokens.length; index++) {
-		const token = tokens[index] ?? "";
-		if (BASH_REDIRECT_RE.test(token)) {
-			addPath(targets, tokens[index + 1]);
-			index++;
-			continue;
-		}
-		const redirectMatch = token.match(/^(?:\d*)>>?(.+)$/);
-		if (redirectMatch?.[1]) {
-			addPath(targets, redirectMatch[1]);
-			continue;
-		}
-		// A heredoc delimiter (`<<EOF`) is a here-document word, NOT a filesystem
-		// target. Consume it without recording a target so a legitimate
-		// `cat <<EOF > /tmp/scratch.md` is judged solely by its redirect target.
-		if (BASH_HEREDOC_RE.test(token)) {
-			index++;
-			continue;
-		}
-		if (/^(?:\d*)<<-?.+$/.test(token)) {
-			continue;
-		}
-		if (isMutationBashCommand(tokens, index)) {
-			for (let targetIndex = index + 1; targetIndex < tokens.length; targetIndex++) {
-				const target = tokens[targetIndex] ?? "";
-				if (isBashCommandBoundary(target)) break;
-				if (target.startsWith("-")) continue;
-				addPath(targets, target);
-			}
-		}
-	}
-	return targets;
-}
-
-function unquoteBashToken(token: string): string {
-	if (token.length < 2) return token;
-	const quote = token[0];
-	if ((quote === "'" || quote === '"') && token.at(-1) === quote) return token.slice(1, -1);
-	return token;
-}
-
-function isBashCommandBoundary(token: string): boolean {
-	return [";", "&&", "||", "|"].includes(token);
-}
-
-function isMutationBashCommand(tokens: string[], index: number): boolean {
-	const token = path.basename(tokens[index] ?? "");
-	if (BASH_MUTATION_COMMANDS.has(token)) return true;
-	if (token !== "sed") return false;
-	const next = tokens[index + 1] ?? "";
-	return next === "-i" || next.startsWith("-i") || next.includes("i");
-}
-
 function extractTargets(tool: ToolWithEditMode, args: unknown): ExtractedTargets {
 	if (tool.name === "write") return extractWriteTargets(args);
 	if (tool.name === "ast_edit") return extractAstEditTargets(args);
 	if (tool.name === "edit") return extractEditTargets(args, tool);
-	if (tool.name === "bash") return extractBashTargets(args);
 	return { paths: [], unknown: true };
 }
 
@@ -460,8 +377,9 @@ function relativeGjcSegments(cwd: string, rawPath: string): string[] | null {
 function blockedWorkflowStateSkill(cwd: string, rawPath: string): CanonicalGjcWorkflowSkill | null {
 	const segments = relativeGjcSegments(cwd, rawPath);
 	if (segments?.[0] !== ".gjc") return null;
-	if (segments[1] === "specs" || segments[1] === "plans") return null;
-	if (segments[1] !== "state") return null;
+	const generatedRoot = segments[1]?.startsWith(GJC_SESSION_PREFIX) ? segments[2] : segments[1];
+	if (generatedRoot === "specs" || generatedRoot === "plans") return null;
+	if (generatedRoot !== "state") return null;
 	const fileName = segments.at(-1) ?? "";
 	for (const skillName of ["deep-interview", "ralplan", "ultragoal", "team"] as const) {
 		if (fileName === workflowModeStateFileName(skillName)) return skillName;
@@ -481,7 +399,8 @@ function firstBlockedWorkflowStateSkill(cwd: string, targets: ExtractedTargets):
 function isAllowlistedPath(cwd: string, rawPath: string): boolean {
 	const segments = relativeGjcSegments(cwd, rawPath);
 	if (segments?.[0] !== ".gjc") return false;
-	return segments[1] === "specs" || segments[1] === "plans";
+	const generatedRoot = segments[1]?.startsWith(GJC_SESSION_PREFIX) ? segments[2] : segments[1];
+	return generatedRoot === "specs" || generatedRoot === "plans";
 }
 function isBlockedGjcPath(cwd: string, rawPath: string): boolean {
 	const segments = relativeGjcSegments(cwd, rawPath);

package/src/skill-state/workflow-hud.ts

@@ -40,7 +40,7 @@ interface UltragoalHudState extends WorkflowGateHudState {
 	currentGoal?: UltragoalLikeGoal;
 	counts: Record<string, number>;
 	goals: UltragoalLikeGoal[];
-	latestLedgerEvent?: { event?: string; goalId?: string; timestamp?: string };
+	latestLedgerEvent?: { event?: string; goalId?: string; timestamp?: string; kind?: string; evidence?: string };
 	updatedAt?: string;
 }
 
@@ -237,7 +237,9 @@ export function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudS
 			chip(
 				"ledger",
 				state.latestLedgerEvent?.event
-					? [state.latestLedgerEvent.event, state.latestLedgerEvent.goalId].filter(Boolean).join(":")
+					? [state.latestLedgerEvent.event, state.latestLedgerEvent.kind, state.latestLedgerEvent.goalId]
+							.filter(Boolean)
+							.join(":")
 					: undefined,
 				35,
 			),

package/src/skill-state/workflow-state-contract.ts

@@ -141,10 +141,10 @@ export function sanctionedWorkflowStateCommand(skill: CanonicalGjcWorkflowSkill)
 export function describeWorkflowStateContract(skill: CanonicalGjcWorkflowSkill): string[] {
 	return [
 		`Sanctioned mutation path: gjc state ${skill} read|write --input '<json>'`,
-		`Canonical active HUD state: .gjc/state/${SKILL_ACTIVE_STATE_FILE} and .gjc/state/sessions/<session>/${SKILL_ACTIVE_STATE_FILE}`,
-		`Skill mode state: .gjc/state/${workflowModeStateFileName(skill)} or .gjc/state/sessions/<session>/${workflowModeStateFileName(skill)}`,
+		`Canonical active HUD state: .gjc/_session-{sessionid}/state/${SKILL_ACTIVE_STATE_FILE}`,
+		`Skill mode state: .gjc/_session-{sessionid}/state/${workflowModeStateFileName(skill)}`,
 		"Receipts include version, skill, owner, command, state_path, storage_path, mutated_at, fresh_until, status, and mutation_id.",
 		"Receipts are fresh for 30 minutes; older receipts are stale and render as HUD warnings.",
-		"Planning artifacts under .gjc/specs/** and .gjc/plans/** remain writable outside the state command.",
+		"Planning artifacts under .gjc/_session-{sessionid}/specs/** and .gjc/_session-{sessionid}/plans/** remain writable outside the state command.",
 	];
 }

package/src/slash-commands/builtin-registry.ts

@@ -797,7 +797,10 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				return;
 			}
 
-			runtime.ctx.showProviderOnboarding();
+			runtime.ctx.showOAuthSelector("login", undefined, {
+				allowExternalCredentialDiscovery: true,
+				trigger: "bare-login",
+			});
 			runtime.ctx.editor.setText("");
 		},
 	},