@gajae-code/coding-agent 0.2.4 → 0.3.0

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

@@ -1,5 +1,10 @@
-import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import {
+	type ActiveSessionScope,
+	rebuildActiveSnapshot,
+	removeActiveEntry,
+	writeActiveEntry,
+} from "../gjc-runtime/state-writer";
 import type { WorkflowStateReceipt } from "./workflow-state-contract";
 
 export const SKILL_ACTIVE_STATE_FILE = "skill-active-state.json";
@@ -56,6 +61,8 @@ export interface SkillActiveState {
 	session_id?: string;
 	thread_id?: string;
 	turn_id?: string;
+	initialized_mode?: CanonicalGjcWorkflowSkill;
+	initialized_state_path?: string;
 	active_skills?: SkillActiveEntry[];
 	[key: string]: unknown;
 }
@@ -286,14 +293,6 @@ export function getSkillActiveStatePaths(cwd: string, sessionId?: string): Skill
 	};
 }
 
-async function readStateFile(filePath: string): Promise<SkillActiveState | null> {
-	try {
-		return normalizeSkillActiveState(JSON.parse(await Bun.file(filePath).text()));
-	} catch {
-		return null;
-	}
-}
-
 /**
  * Raw read for handoff mutations. Returns the *unnormalized* parsed object so
  * inactive entries remain visible to `rawActiveEntries` — `normalizeSkillActiveState`
@@ -327,11 +326,33 @@ async function readRawActiveStateForHandoff(filePath: string, strict: boolean):
 }
 
 function rawActiveEntries(state: SkillActiveState | null): SkillActiveEntry[] {
-	if (!state || !Array.isArray(state.active_skills)) return [];
+	if (!state) return [];
 	const out: SkillActiveEntry[] = [];
-	for (const candidate of state.active_skills) {
-		const normalized = normalizeEntry(candidate);
-		if (normalized) out.push(normalized);
+	if (Array.isArray(state.active_skills)) {
+		for (const candidate of state.active_skills) {
+			const normalized = normalizeEntry(candidate);
+			if (normalized) out.push(normalized);
+		}
+	}
+	// Legacy top-level fallback: pre-`active_skills` state files persisted a single
+	// active workflow as top-level `{ active: true, skill, phase, … }` with no
+	// `active_skills` array. `normalizeSkillActiveState` still synthesizes that row,
+	// so the raw read used by the HUD, mutation guard, and caller inference must do
+	// the same or it would treat a legacy active workflow as absent.
+	if (out.length === 0 && state.active === true) {
+		const skill = safeString(state.skill).trim();
+		if (skill) {
+			out.push({
+				skill,
+				phase: safeString(state.phase).trim() || undefined,
+				active: true,
+				activated_at: safeString(state.activated_at).trim() || undefined,
+				updated_at: safeString(state.updated_at).trim() || undefined,
+				session_id: safeString(state.session_id).trim() || undefined,
+				thread_id: safeString(state.thread_id).trim() || undefined,
+				turn_id: safeString(state.turn_id).trim() || undefined,
+			});
+		}
 	}
 	return out;
 }
@@ -345,24 +366,139 @@ function filterRootEntriesForSession(entries: SkillActiveEntry[], sessionId?: st
 	});
 }
 
+function entryRecency(entry: SkillActiveEntry): number {
+	const stamp = entry.handoff_at || entry.updated_at || entry.activated_at;
+	const ms = stamp ? Date.parse(stamp) : Number.NaN;
+	// NaN signals "no trustworthy timestamp" so comparisons can refuse to let an
+	// unknown-recency row win a tie; callers must treat NaN explicitly.
+	return ms;
+}
+
+/**
+ * Session ownership rank for a row visible to a `sessionId` read. When a concrete
+ * session is in scope, a row owned by that exact session outranks a session-less
+ * fallback row, which outranks a foreign-session row. Session-less rows are global
+ * fallbacks and must never override a session's own state. With no scope session,
+ * every row ranks equally.
+ */
+function sessionScopeRank(entry: SkillActiveEntry, sessionId?: string): number {
+	const scope = safeString(sessionId).trim();
+	if (!scope) return 0;
+	const entrySession = safeString(entry.session_id).trim();
+	if (entrySession === scope) return 2;
+	if (entrySession.length === 0) return 1;
+	return 0;
+}
+
+/**
+ * Pick the surviving row for a single skill within a session-scoped visible set.
+ * Precedence, highest first:
+ *   1. exact-session ownership over a session-less fallback row,
+ *   2. a strictly-newer valid timestamp,
+ *   3. a valid timestamp over a missing/unparseable one,
+ *   4. active over inactive — so an untrustworthy inactive row can never hide an
+ *      active row — then merge order for a total tie.
+ * A genuine handoff demotion still supersedes a stale active row of the same skill
+ * because, within one session scope, it carries the newest valid timestamp.
+ */
+function moreVisibleEntry(
+	incumbent: SkillActiveEntry,
+	challenger: SkillActiveEntry,
+	sessionId?: string,
+): SkillActiveEntry {
+	const scopeDelta = sessionScopeRank(incumbent, sessionId) - sessionScopeRank(challenger, sessionId);
+	if (scopeDelta !== 0) return scopeDelta > 0 ? incumbent : challenger;
+	const ri = entryRecency(incumbent);
+	const rc = entryRecency(challenger);
+	const vi = Number.isFinite(ri);
+	const vc = Number.isFinite(rc);
+	if (vi && vc && ri !== rc) return ri > rc ? incumbent : challenger;
+	if (vi !== vc) return vi ? incumbent : challenger;
+	const incumbentActive = incumbent.active !== false;
+	const challengerActive = challenger.active !== false;
+	if (incumbentActive !== challengerActive) return incumbentActive ? incumbent : challenger;
+	return incumbent;
+}
+
+/**
+ * Collapse the merged, session-scoped entries down to a single row per skill.
+ * A handed-off skill can leave more than one row visible to a session — e.g. a
+ * row seeded without a session id (rendered globally by
+ * `filterRootEntriesForSession`) plus a later, session-scoped handoff demotion
+ * of the same skill. Without this collapse the HUD renders the same workflow
+ * twice and keeps showing a skill that has already handed control to its
+ * successor. `moreVisibleEntry` picks the winner so a handoff demotion supersedes
+ * an older stale `active:true` row (and is then dropped by the active filter
+ * below) while a session's own active row is never hidden by a session-less or
+ * untrustworthy-timestamp row.
+ */
+function dedupeVisibleBySkill(entries: SkillActiveEntry[], sessionId?: string): SkillActiveEntry[] {
+	const winners = new Map<string, SkillActiveEntry>();
+	for (const entry of entries) {
+		const current = winners.get(entry.skill);
+		winners.set(entry.skill, current ? moreVisibleEntry(current, entry, sessionId) : entry);
+	}
+	return [...winners.values()];
+}
+
+/**
+ * The planning pipeline advances one stage at a time: `deep-interview →
+ * ralplan → ultragoal`. Each stage is activated through its own command path
+ * (`gjc deep-interview`, `gjc ralplan`, `gjc ultragoal`), and those activations
+ * do not demote the previous stage's row — only the explicit `handoff` verb
+ * does. Without this collapse, activating ultragoal while ralplan is still
+ * `active:true` would render both stages and keep showing a workflow that has
+ * already handed control forward. Keep only the most recently updated pipeline
+ * stage so the HUD reflects the single current workflow. `team` is intentionally
+ * excluded — it runs alongside ultragoal — and every non-pipeline skill is left
+ * untouched.
+ *
+ * This is a HUD-display policy only. It is applied by the skill HUD renderer and
+ * deliberately NOT folded into `readVisibleSkillActiveState`, whose callers (the
+ * deep-interview mutation guard and handoff caller inference) must keep seeing
+ * every genuinely-active skill rather than the single most-recent pipeline stage.
+ */
+const PLANNING_PIPELINE_SKILLS = new Set<string>(["deep-interview", "ralplan", "ultragoal"]);
+
+export function collapsePlanningPipeline(entries: readonly SkillActiveEntry[]): SkillActiveEntry[] {
+	const pipeline = entries.filter(entry => PLANNING_PIPELINE_SKILLS.has(entry.skill));
+	if (pipeline.length <= 1) return [...entries];
+	let current = pipeline[0];
+	let currentRecency = entryRecency(current);
+	for (const entry of pipeline) {
+		const recency = entryRecency(entry);
+		// Prefer a strictly-newer valid timestamp; a valid timestamp also beats a
+		// missing/unparseable one. Ties (or all-invalid) keep the first stage
+		// deterministically rather than letting an unknown-recency row win.
+		const better = Number.isFinite(recency) && (!Number.isFinite(currentRecency) || recency > currentRecency);
+		if (better) {
+			current = entry;
+			currentRecency = recency;
+		}
+	}
+	return entries.filter(entry => !PLANNING_PIPELINE_SKILLS.has(entry.skill) || entry === current);
+}
+
 function mergeVisibleEntries(
 	sessionState: SkillActiveState | null,
 	rootState: SkillActiveState | null,
 	sessionId?: string,
 ): SkillActiveEntry[] {
-	const rootEntries = filterRootEntriesForSession(listActiveSkills(rootState), sessionId);
+	// 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.
+	const rootEntries = filterRootEntriesForSession(rawActiveEntries(rootState), sessionId);
 	const merged = new Map(rootEntries.map(entry => [entryKey(entry), entry]));
-	for (const entry of listActiveSkills(sessionState)) {
+	for (const entry of rawActiveEntries(sessionState)) {
 		merged.set(entryKey(entry), entry);
 	}
-	return [...merged.values()];
+	return dedupeVisibleBySkill([...merged.values()], sessionId).filter(entry => entry.active !== false);
 }
 
 export async function readVisibleSkillActiveState(cwd: string, sessionId?: string): Promise<SkillActiveState | null> {
 	const { rootPath, sessionPath } = getSkillActiveStatePaths(cwd, sessionId);
 	const [rootState, sessionState] = await Promise.all([
-		readStateFile(rootPath),
-		sessionPath ? readStateFile(sessionPath) : Promise.resolve(null),
+		readRawActiveStateForHandoff(rootPath, false),
+		sessionPath ? readRawActiveStateForHandoff(sessionPath, false) : Promise.resolve(null),
 	]);
 	const activeSkills = mergeVisibleEntries(sessionState, rootState, sessionId);
 	if (activeSkills.length === 0) return null;
@@ -379,15 +515,41 @@ export async function readVisibleSkillActiveState(cwd: string, sessionId?: strin
 	};
 }
 
-async function writeStateFile(filePath: string, state: SkillActiveState): Promise<void> {
-	await fs.mkdir(path.dirname(filePath), { recursive: true });
-	await Bun.write(filePath, `${JSON.stringify(state, null, 2)}\n`);
+function activeStateWriterAudit(verb: string) {
+	return { category: "state" as const, verb, owner: "gjc-runtime" as const };
+}
+
+async function persistActiveEntry(
+	cwd: string,
+	sessionScope: ActiveSessionScope | undefined,
+	entry: SkillActiveEntry,
+): Promise<void> {
+	if (entry.active === false) {
+		await removeActiveEntry(cwd, sessionScope, entry.skill, {
+			cwd,
+			audit: activeStateWriterAudit("remove-active-entry"),
+		});
+	} else {
+		await writeActiveEntry(cwd, sessionScope, entry.skill, entry, {
+			cwd,
+			audit: activeStateWriterAudit("write-active-entry"),
+		});
+	}
+}
+
+async function writeHandoffEntry(
+	cwd: string,
+	sessionScope: ActiveSessionScope | undefined,
+	entry: SkillActiveEntry,
+): Promise<void> {
+	await writeActiveEntry(cwd, sessionScope, entry.skill, entry, {
+		cwd,
+		audit: activeStateWriterAudit("write-active-entry"),
+	});
 }
 
-function upsertEntry(entries: SkillActiveEntry[], entry: SkillActiveEntry, active: boolean): SkillActiveEntry[] {
-	const key = entryKey(entry);
-	const retained = entries.filter(candidate => entryKey(candidate) !== key);
-	return active ? [...retained, entry] : retained;
+async function rebuildActiveState(cwd: string, sessionScope?: ActiveSessionScope): Promise<void> {
+	await rebuildActiveSnapshot(cwd, sessionScope, { cwd, audit: activeStateWriterAudit("rebuild-active-snapshot") });
 }
 
 export async function syncSkillActiveState(options: SyncSkillActiveStateOptions): Promise<void> {
@@ -408,36 +570,13 @@ export async function syncSkillActiveState(options: SyncSkillActiveStateOptions)
 		...(hud ? { hud } : {}),
 		...(options.receipt ? { receipt: options.receipt } : {}),
 	};
-	const { rootPath, sessionPath } = getSkillActiveStatePaths(options.cwd, options.sessionId);
-	const rootState = (await readStateFile(rootPath)) ?? { version: 1, active_skills: [] };
-	const rootEntries = upsertEntry(listActiveSkills(rootState), entry, options.active);
-	const nextRoot: SkillActiveState = {
-		...rootState,
-		version: 1,
-		active: rootEntries.length > 0,
-		skill: rootEntries[0]?.skill ?? "",
-		phase: rootEntries[0]?.phase ?? "",
-		updated_at: nowIso,
-		source: options.source,
-		active_skills: rootEntries,
-	};
-	await writeStateFile(rootPath, nextRoot);
+	await persistActiveEntry(options.cwd, undefined, entry);
+	await rebuildActiveState(options.cwd);
 
-	if (!sessionPath) return;
-	const sessionState = (await readStateFile(sessionPath)) ?? { version: 1, active_skills: [] };
-	const sessionEntries = upsertEntry(listActiveSkills(sessionState), entry, options.active);
-	const nextSession: SkillActiveState = {
-		...sessionState,
-		version: 1,
-		active: sessionEntries.length > 0,
-		skill: sessionEntries[0]?.skill ?? "",
-		phase: sessionEntries[0]?.phase ?? "",
-		session_id: options.sessionId,
-		updated_at: nowIso,
-		source: options.source,
-		active_skills: sessionEntries,
-	};
-	await writeStateFile(sessionPath, nextSession);
+	if (!options.sessionId) return;
+	const sessionScope = { sessionId: options.sessionId };
+	await persistActiveEntry(options.cwd, sessionScope, entry);
+	await rebuildActiveState(options.cwd, sessionScope);
 }
 
 export interface ApplyHandoffOptions {
@@ -467,12 +606,27 @@ export async function applyHandoffToActiveState(options: ApplyHandoffOptions): P
 	const sessionId = options.callee.sessionId ?? options.caller.sessionId;
 	const { rootPath, 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.
+	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;
+	};
 	const applyEntries = (entries: SkillActiveEntry[]): SkillActiveEntry[] => {
 		const callerKey = entryKey(callerEntry);
-		const calleeKey = entryKey(calleeEntry);
-		const priorCaller = entries.find(e => entryKey(e) === callerKey);
-		const kept = entries.filter(e => entryKey(e) !== callerKey && entryKey(e) !== calleeKey);
+		const priorCaller =
+			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.
@@ -486,33 +640,23 @@ export async function applyHandoffToActiveState(options: ApplyHandoffOptions): P
 			: callerEntry;
 		return [...kept, mergedCaller, calleeEntry];
 	};
-	const buildNextState = (
+	const writeEntries = async (
+		sessionScope: ActiveSessionScope | undefined,
 		prior: SkillActiveState | null,
-		entries: SkillActiveEntry[],
-		scope: "session" | "root",
-	): SkillActiveState => {
-		const visible = entries.filter(e => e.active !== false);
-		return {
-			...(prior ?? {}),
-			version: 1,
-			active: visible.length > 0,
-			skill: visible[0]?.skill ?? "",
-			phase: visible[0]?.phase ?? "",
-			...(scope === "session" ? { session_id: sessionId } : {}),
-			updated_at: nowIso,
-			source: options.callee.source ?? options.caller.source,
-			active_skills: entries,
-		};
+	): Promise<void> => {
+		const nextEntries = applyEntries(rawActiveEntries(prior));
+		for (const entry of nextEntries) {
+			await writeHandoffEntry(options.cwd, sessionScope, entry);
+		}
+		await rebuildActiveState(options.cwd, sessionScope);
 	};
 
 	if (sessionPath) {
 		const prior = await readState(sessionPath);
-		const next = buildNextState(prior, applyEntries(rawActiveEntries(prior)), "session");
-		await writeStateFile(sessionPath, next);
+		await writeEntries({ sessionId }, prior);
 	}
 	const priorRoot = await readState(rootPath);
-	const nextRoot = buildNextState(priorRoot, applyEntries(rawActiveEntries(priorRoot)), "root");
-	await writeStateFile(rootPath, nextRoot);
+	await writeEntries(undefined, priorRoot);
 }
 
 function buildSyncEntry(options: SyncSkillActiveStateOptions, nowIso: string): SkillActiveEntry {

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

@@ -14,12 +14,16 @@ import {
 export const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE =
 	"Deep-interview phase boundary: continue gathering context/questions/risks and emit a handoff/spec before code edits. Mutation tools and patch execution are blocked while deep-interview is active; finalize specs through `gjc deep-interview --write --stage final` or hand off to an execution phase.";
 export const WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE =
-	"Workflow state JSON is runtime-owned. Use `gjc state <skill> read|write --input '<json>'` for deep-interview, ralplan, ultragoal, and team. Planning artifacts under `.gjc/specs/` and `.gjc/plans/` remain allowed.";
+	".gjc workflow state and artifacts are runtime-owned. Agent mutation tools cannot edit `.gjc/**`; use the sanctioned `gjc` CLI instead.";
 
-const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit"]);
+const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit", "bash"]);
 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*)<<-?$/;
+const BASH_MUTATION_COMMANDS = new Set(["rm", "mv", "cp", "touch", "mkdir", "ln", "tee"]);
 
 type ToolWithEditMode = AgentTool & {
 	mode?: unknown;
@@ -219,10 +223,75 @@ 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;
+	}
+	if (/^gjc(?:\s|$)/.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;
+		}
+		if (BASH_HEREDOC_RE.test(token)) {
+			addPath(targets, tokens[index + 1]);
+			index++;
+			continue;
+		}
+		const heredocMatch = token.match(/^(?:\d*)<<-?(.+)$/);
+		if (heredocMatch?.[1]) {
+			addPath(targets, heredocMatch[1]);
+			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 };
 }
 
@@ -289,6 +358,14 @@ function isAllowlistedPath(cwd: string, rawPath: string): boolean {
 	if (segments?.[0] !== ".gjc") return false;
 	return segments[1] === "specs" || segments[1] === "plans";
 }
+function isBlockedGjcPath(cwd: string, rawPath: string): boolean {
+	const segments = relativeGjcSegments(cwd, rawPath);
+	return segments?.[0] === ".gjc";
+}
+
+function hasBlockedGjcTarget(cwd: string, targets: ExtractedTargets): boolean {
+	return targets.paths.some(rawPath => isBlockedGjcPath(cwd, rawPath));
+}
 
 function allTargetsAllowlisted(cwd: string, targets: ExtractedTargets): boolean {
 	return (
@@ -315,18 +392,16 @@ export async function getDeepInterviewMutationDecision(
 ): Promise<DeepInterviewMutationDecision> {
 	if (!BLOCKED_TOOL_NAMES.has(input.tool.name)) return { blocked: false, targets: [] };
 	const targets = extractTargets(input.tool, input.args);
-	if (input.enforceWorkflowState !== false) {
+	if (input.enforceWorkflowState !== false && hasBlockedGjcTarget(input.cwd, targets)) {
 		const stateSkill = firstBlockedWorkflowStateSkill(input.cwd, targets);
-		if (stateSkill) {
-			const command = sanctionedWorkflowStateCommand(stateSkill);
-			return {
-				blocked: true,
-				message: `${WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE}\nUse: ${command}`,
-				targets: targets.paths,
-				reason: "workflow-state-target",
-				command,
-			};
-		}
+		const command = stateSkill ? sanctionedWorkflowStateCommand(stateSkill) : "gjc <workflow-command>";
+		return {
+			blocked: true,
+			message: `${WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE}\nUse: ${command}`,
+			targets: targets.paths,
+			reason: stateSkill ? "workflow-state-target" : "gjc-target",
+			command,
+		};
 	}
 	if (!(await isActiveDeepInterview(input.cwd, input.sessionId, input.threadId))) {
 		return { blocked: false, targets: [] };
@@ -340,6 +415,9 @@ export async function getDeepInterviewMutationDecision(
 			reason: "unknown-target",
 		};
 	}
+	if (input.tool.name === "bash") {
+		return { blocked: false, targets: targets.paths };
+	}
 	return {
 		blocked: true,
 		message: DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE,

package/src/skill-state/initial-phase.ts

@@ -13,5 +13,7 @@ import type { CanonicalGjcWorkflowSkill } from "./active-state";
 export function initialPhaseForSkill(skill: CanonicalGjcWorkflowSkill | string): string {
 	if (skill === "deep-interview") return "interviewing";
 	if (skill === "ultragoal") return "goal-planning";
+	if (skill === "ralplan") return "planner";
+	if (skill === "team") return "starting";
 	return "planning";
 }

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

@@ -9,6 +9,13 @@ export const WORKFLOW_STATE_RECEIPT_FRESH_MS = 30 * 60 * 1000;
 export type WorkflowStateMutationOwner = "gjc-state-cli" | "gjc-runtime" | "gjc-hook";
 export type WorkflowStateReceiptStatus = "fresh" | "stale";
 
+export interface WorkflowStateContentChecksum {
+	algorithm: "sha256";
+	value: string;
+	covered_path: string;
+	computed_at: string;
+}
+
 export interface WorkflowStateReceipt {
 	version: 1;
 	skill: CanonicalGjcWorkflowSkill;
@@ -20,6 +27,25 @@ export interface WorkflowStateReceipt {
 	fresh_until: string;
 	status: WorkflowStateReceiptStatus;
 	mutation_id: string;
+	verb?: string;
+	from_phase?: string;
+	to_phase?: string;
+	forced?: boolean;
+	paths?: string[];
+	content_sha256?: WorkflowStateContentChecksum;
+}
+
+export interface AuditEntry {
+	ts: string;
+	skill?: string;
+	category: string;
+	verb: string;
+	owner: WorkflowStateMutationOwner;
+	mutation_id: string;
+	from_phase?: string;
+	to_phase?: string;
+	forced: boolean;
+	paths: string[];
 }
 
 function safeString(value: unknown): string {

package/src/task/agents.ts

@@ -30,6 +30,7 @@ interface AgentFrontmatter {
 	blocking?: boolean;
 	hide?: boolean;
 	forkContext?: "forbidden" | "allowed";
+	bashAllowedPrefixes?: string[];
 }
 
 interface EmbeddedAgentDef {