@gajae-code/coding-agent 0.11.0 → 0.11.2

package/src/session/volatile-context-pruning.ts

@@ -0,0 +1,78 @@
+import type { CustomMessageEntry, SessionEntry } from "./session-manager";
+
+const SUPERSEDED_VOLATILE_CONTEXT_NOTICE = "[superseded volatile context pruned]";
+
+/**
+ * Custom messages whose producer maintains one current singleton state:
+ * - todo-write-error-reminder: a later todo-write failure replaces the prior warning.
+ * - resolve-reminder: only the currently pending resolve preview can be applied.
+ * - eager-todo-prelude: the newest todo prelude reflects the current task state.
+ */
+const SUPERSEDED_SINGLETON_REMINDER_TYPES = new Set([
+	"todo-write-error-reminder",
+	"resolve-reminder",
+	"eager-todo-prelude",
+]);
+
+/**
+ * Volatile context is refreshed for every prompt. Only its newest copy is useful;
+ * replacing older copies at a maintenance boundary preserves the audit trail
+ * without repeatedly charging the model for stale workspace snapshots.
+ */
+export function pruneSupersededVolatileProjectContext(entries: readonly SessionEntry[]): {
+	changed: CustomMessageEntry[];
+	bytesSaved: number;
+} {
+	let latest = -1;
+	entries.forEach((entry, index) => {
+		if (entry.type === "custom_message" && entry.customType === "volatile-project-context") latest = index;
+	});
+	if (latest < 0) return { changed: [], bytesSaved: 0 };
+
+	const changed: CustomMessageEntry[] = [];
+	let bytesSaved = 0;
+	entries.forEach((entry, index) => {
+		if (index >= latest || entry.type !== "custom_message" || entry.customType !== "volatile-project-context") return;
+		const content =
+			typeof entry.content === "string"
+				? entry.content
+				: entry.content.map(block => (block.type === "text" ? block.text : "")).join("\n");
+		if (!content) return;
+		entry.content = SUPERSEDED_VOLATILE_CONTEXT_NOTICE;
+		bytesSaved += Buffer.byteLength(content, "utf-8");
+		changed.push(entry as CustomMessageEntry);
+	});
+	return { changed, bytesSaved };
+}
+
+/** Retire superseded known singleton maintenance reminders without touching ordinary user context. */
+export function pruneSupersededMaintenanceReminders(entries: readonly SessionEntry[]): {
+	changed: CustomMessageEntry[];
+	bytesSaved: number;
+} {
+	const latest = new Map<string, number>();
+	entries.forEach((entry, index) => {
+		if (entry.type === "custom_message" && SUPERSEDED_SINGLETON_REMINDER_TYPES.has(entry.customType)) {
+			latest.set(entry.customType, index);
+		}
+	});
+	const changed: CustomMessageEntry[] = [];
+	let bytesSaved = 0;
+	entries.forEach((entry, index) => {
+		if (
+			entry.type !== "custom_message" ||
+			latest.get(entry.customType) === undefined ||
+			latest.get(entry.customType) === index
+		)
+			return;
+		const text =
+			typeof entry.content === "string"
+				? entry.content
+				: entry.content.map(block => (block.type === "text" ? block.text : "")).join("\n");
+		if (!text) return;
+		entry.content = SUPERSEDED_VOLATILE_CONTEXT_NOTICE;
+		bytesSaved += Buffer.byteLength(text, "utf-8");
+		changed.push(entry);
+	});
+	return { changed, bytesSaved };
+}

package/src/setup/credential-auto-import.ts

@@ -211,7 +211,8 @@ export function isCredentialAutoImportStateResolvedForVersion(
 	version: string,
 ): boolean {
 	return (
-		state.initialImportResolution !== undefined ||
+		state.initialImportResolution === "declined" ||
+		(state.initialImportResolution === "accepted" && state.lastImportVersion === undefined) ||
 		(state.lastImportVersion !== undefined && state.lastImportVersion === version)
 	);
 }

package/src/setup/hermes/templates/operator-instructions.v1.md

@@ -11,7 +11,7 @@ These instructions teach a Hermes-style coordinator how to operate GJC through t
 3. Store the returned `turn_id`.
 4. Prefer `{{TOOL_PREFIX}}_watch_events` with the stored `latest_seq` for event-driven progress; fall back to `{{TOOL_PREFIX}}_read_turn` or `{{TOOL_PREFIX}}_await_turn` for a specific `turn_id` until terminal.
    If a second task is needed while one turn is active, pass `queue: true`; the next queued turn is promoted after the active turn is reported terminal.
-5. If GJC asks a structured question, use `{{TOOL_PREFIX}}_list_questions` and answer with `{{TOOL_PREFIX}}_submit_question_answer`.
+5. If GJC asks structured questions, call `{{TOOL_PREFIX}}_list_questions` with `session_id`. It reconciles pending `workflow.gates.list` rows and returns bounded public questions, diagnostics, and reconciliation; `pending` is the current filter and `open` is a compatibility alias. Handle every pending row. Submit its `session_id`, `turn_id`, `question_id`, and `answer_binding` to `{{TOOL_PREFIX}}_submit_question_answer` with the advertised `answer`, a unique `idempotency_key`, and `allow_mutation: true`. That tool resolves through `workflow.gate_answer`, never generic `ask.answer`; re-list after restart, incomplete reconciliation is `terminal_uncertain`, stale/terminal rows are not answerable, identical replay is safe, and conflicting idempotency-key reuse fails. Never expect private gate payloads or raw values. This coordinator loop is separate from #2549/#2551 and unattended plain-CLI behavior.
 6. Use `{{TOOL_PREFIX}}_report_status` for coordinator-visible status and final reports.
 7. Use `{{TOOL_PREFIX}}_read_tail` only to inspect the latest assistant response through the SDK when structured turn state is insufficient; it never reads terminal output.
 

package/src/setup/provider-onboarding.ts

@@ -1,8 +1,11 @@
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { getAgentDir } from "@gajae-code/utils";
+import { getAgentDbPath, getAgentDir } from "@gajae-code/utils";
 import { YAML } from "bun";
 import { type ModelsConfig, ModelsConfigSchema } from "../config/models-config-schema";
+import { AuthStorage } from "../session/auth-storage";
+import providerPresets from "./provider-presets.json";
 
 export type ProviderCompatibility = "openai" | "anthropic";
 export type ProviderSetupApi = "openai-responses" | "openai-completions" | "anthropic-messages";
@@ -52,63 +55,7 @@ interface ProviderPreset {
 const PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 const REDACT_PREFIX = 4;
 const REDACT_SUFFIX = 4;
-// Preset compat values are onboarding snapshots for generated models.yml entries.
-// Keep them aligned with provider descriptor behavior without importing descriptor internals into setup UX.
-const MINIMAX_OPENAI_COMPAT: ProviderCompatConfig = {
-	supportsStore: false,
-	supportsDeveloperRole: false,
-	supportsReasoningEffort: false,
-	reasoningContentField: "reasoning_content",
-};
-
-const GLM_OPENAI_COMPAT: ProviderCompatConfig = {
-	supportsDeveloperRole: false,
-	supportsReasoningEffort: false,
-	thinkingFormat: "zai",
-	reasoningContentField: "reasoning_content",
-};
-
-export const PROVIDER_PRESETS: readonly ProviderPreset[] = [
-	{
-		id: "minimax",
-		aliases: ["minimax-code"],
-		name: "MiniMax Coding Plan",
-		description: "OpenAI-compatible MiniMax Coding Plan endpoint",
-		compatibility: "openai",
-		api: "openai-completions",
-		providerId: "minimax-code",
-		baseUrl: "https://api.minimax.io/v1",
-		apiKeyEnv: "MINIMAX_CODE_API_KEY",
-		models: ["minimax-m3"],
-		compat: MINIMAX_OPENAI_COMPAT,
-	},
-	{
-		id: "minimax-cn",
-		aliases: ["minimax-code-cn", "minimaxi"],
-		name: "MiniMax Coding Plan (China)",
-		description: "OpenAI-compatible MiniMax China endpoint",
-		compatibility: "openai",
-		api: "openai-completions",
-		providerId: "minimax-code-cn",
-		baseUrl: "https://api.minimaxi.com/v1",
-		apiKeyEnv: "MINIMAX_CODE_CN_API_KEY",
-		models: ["minimax-m3"],
-		compat: MINIMAX_OPENAI_COMPAT,
-	},
-	{
-		id: "glm",
-		aliases: ["zai", "z-ai", "bigmodel"],
-		name: "GLM / zAI",
-		description: "OpenAI-compatible GLM endpoint from zAI/BigModel",
-		compatibility: "openai",
-		api: "openai-completions",
-		providerId: "glm-proxy",
-		baseUrl: "https://api.z.ai/api/paas/v4",
-		apiKeyEnv: "ZAI_API_KEY",
-		models: ["glm-4.6"],
-		compat: GLM_OPENAI_COMPAT,
-	},
-];
+export const PROVIDER_PRESETS: readonly ProviderPreset[] = providerPresets as ProviderPreset[];
 
 export function getDefaultModelsPath(): string {
 	return path.join(getAgentDir(), "models.yml");
@@ -290,8 +237,31 @@ async function writeModelsConfig(modelsPath: string, config: ModelsConfig): Prom
 		const where = first?.path.length ? `/${first.path.map(String).join("/")}` : "root";
 		throw new Error(`Generated models config is invalid at ${where}: ${first?.message ?? "unknown schema error"}`);
 	}
-	await fs.mkdir(path.dirname(modelsPath), { recursive: true });
-	await Bun.write(modelsPath, YAML.stringify(checked.data, null, 2));
+	const directory = path.dirname(modelsPath);
+	await fs.mkdir(directory, { recursive: true });
+	const tempPath = path.join(directory, `.${path.basename(modelsPath)}.${process.pid}.${randomUUID()}.tmp`);
+	try {
+		const tempHandle = await fs.open(tempPath, "wx", 0o600);
+		try {
+			await tempHandle.writeFile(YAML.stringify(checked.data, null, 2), "utf8");
+			await tempHandle.sync();
+		} finally {
+			await tempHandle.close();
+		}
+		await fs.rename(tempPath, modelsPath);
+		try {
+			const directoryHandle = await fs.open(directory, "r");
+			try {
+				await directoryHandle.sync();
+			} finally {
+				await directoryHandle.close();
+			}
+		} catch {
+			// Directory fsync is unavailable on some filesystems; the replacement succeeded.
+		}
+	} finally {
+		await fs.rm(tempPath, { force: true }).catch(() => undefined);
+	}
 }
 
 export async function addApiCompatibleProvider(input: ProviderSetupInput): Promise<ProviderSetupResult> {
@@ -311,7 +281,12 @@ export async function addApiCompatibleProvider(input: ProviderSetupInput): Promi
 	if (validated.credentialSource === "env") {
 		provider.apiKeyEnv = validated.apiKey;
 	} else {
-		provider.apiKey = validated.apiKey;
+		const authStorage = await AuthStorage.create(getAgentDbPath());
+		try {
+			await authStorage.set(validated.providerId, { type: "api_key", key: validated.apiKey });
+		} finally {
+			authStorage.close();
+		}
 	}
 	const next: ModelsConfig = {
 		...existing,

package/src/setup/provider-presets.json

@@ -0,0 +1,5 @@
+[
+  {"id":"minimax","aliases":["minimax-code"],"name":"MiniMax Coding Plan","description":"OpenAI-compatible MiniMax Coding Plan endpoint","compatibility":"openai","api":"openai-completions","providerId":"minimax-code","baseUrl":"https://api.minimax.io/v1","apiKeyEnv":"MINIMAX_CODE_API_KEY","models":["minimax-m3"],"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning_content"}},
+  {"id":"minimax-cn","aliases":["minimax-code-cn","minimaxi"],"name":"MiniMax Coding Plan (China)","description":"OpenAI-compatible MiniMax China endpoint","compatibility":"openai","api":"openai-completions","providerId":"minimax-code-cn","baseUrl":"https://api.minimaxi.com/v1","apiKeyEnv":"MINIMAX_CODE_CN_API_KEY","models":["minimax-m3"],"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning_content"}},
+  {"id":"glm","aliases":["zai","z-ai","bigmodel"],"name":"GLM / zAI","description":"OpenAI-compatible GLM endpoint from zAI/BigModel","compatibility":"openai","api":"openai-completions","providerId":"glm-proxy","baseUrl":"https://api.z.ai/api/paas/v4","apiKeyEnv":"ZAI_API_KEY","models":["glm-4.6"],"compat":{"supportsDeveloperRole":false,"supportsReasoningEffort":false,"thinkingFormat":"zai","reasoningContentField":"reasoning_content"}}
+]

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

@@ -16,6 +16,7 @@ import {
 	setActiveStateCacheInvalidator,
 	writeActiveEntry,
 } from "../gjc-runtime/state-writer";
+import { getSkillManifest } from "../gjc-runtime/workflow-manifest";
 import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill } from "./canonical-skills";
 import type { WorkflowStateReceipt } from "./workflow-state-contract";
 
@@ -445,29 +446,18 @@ async function readModeStatePhase(
 		const record = parsed as Record<string, unknown>;
 		const phase = safeString(record.current_phase).trim();
 		if (!phase) return undefined;
-		if (record.active === false && !RALPLAN_CANONICAL_PHASE_OVERRIDES.has(phase)) return undefined;
+		if (record.active === false && !getSkillManifest("ralplan").canonicalOverrides.includes(phase)) return undefined;
 		return phase;
 	} catch {
 		return undefined;
 	}
 }
 
-const RALPLAN_CANONICAL_PHASE_OVERRIDES = new Set([
-	"final",
-	"handoff",
-	"complete",
-	"completed",
-	"failed",
-	"cancelled",
-	"canceled",
-	"inactive",
-]);
-
 function withCanonicalRalplanPhase(entry: SkillActiveEntry, canonicalPhase: string | undefined): SkillActiveEntry {
 	if (
 		entry.skill !== "ralplan" ||
 		!canonicalPhase ||
-		!RALPLAN_CANONICAL_PHASE_OVERRIDES.has(canonicalPhase) ||
+		!getSkillManifest("ralplan").canonicalOverrides.includes(canonicalPhase) ||
 		entry.phase === canonicalPhase
 	) {
 		return entry;

package/src/skill-state/{deep-interview-mutation-guard.ts → workflow-mutation-guard.ts}

@@ -7,6 +7,7 @@ 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 { getSkillManifest } from "../gjc-runtime/workflow-manifest";
 import { LocalProtocolHandler, resolveLocalUrlToPath } from "../internal-urls/local-protocol";
 import { resolveToCwd } from "../tools/path-utils";
 import { ToolError } from "../tools/tool-errors";
@@ -51,7 +52,7 @@ type ToolWithEditMode = AgentTool & {
 	customWireName?: unknown;
 };
 
-export interface DeepInterviewMutationGuardInput {
+export interface WorkflowMutationGuardInput {
 	cwd: string;
 	sessionId?: string;
 	threadId?: string;
@@ -59,6 +60,7 @@ export interface DeepInterviewMutationGuardInput {
 	args: unknown;
 	forceOverride?: boolean;
 	enforceWorkflowState?: boolean;
+	guardContext?: WorkflowGuardContext;
 }
 
 interface ExtractedTargets {
@@ -66,7 +68,7 @@ interface ExtractedTargets {
 	unknown: boolean;
 }
 
-export interface DeepInterviewMutationDecision {
+export interface WorkflowMutationDecision {
 	blocked: boolean;
 	message?: string;
 	targets: string[];
@@ -74,6 +76,12 @@ export interface DeepInterviewMutationDecision {
 	command?: string;
 }
 
+export interface WorkflowGuardContext {
+	sessionId: string | null;
+	activeState: Awaited<ReturnType<typeof readVisibleSkillActiveState>>;
+	modeStates: ReadonlyMap<string, ModeState | null>;
+}
+
 interface ModeState {
 	active?: boolean;
 	current_phase?: string;
@@ -125,8 +133,23 @@ async function readValidatedModeState(filePath: string): Promise<ModeState | nul
 	}
 	return state;
 }
-async function readVisibleModeState(cwd: string, skill: string, sessionId: string): Promise<ModeState | null> {
-	return await readValidatedModeState(modeStatePath(cwd, skill, sessionId));
+
+export async function readWorkflowGuardContext(
+	cwd: string,
+	options: { sessionId?: string; threadId?: string } = {},
+): Promise<WorkflowGuardContext> {
+	const sessionId = await resolveBoundarySessionId(cwd, options.sessionId);
+	if (!sessionId) return { sessionId: null, activeState: null, modeStates: new Map() };
+	const activeState = await readVisibleSkillActiveState(cwd, sessionId, { tier: "security" });
+	const skills = activeState ? [...new Set(listActiveSkills(activeState).map(entry => entry.skill))] : [];
+	const modeStates = new Map(
+		await Promise.all(
+			skills.map(
+				async skill => [skill, await readValidatedModeState(modeStatePath(cwd, skill, sessionId))] as const,
+			),
+		),
+	);
+	return { sessionId, activeState, modeStates };
 }
 
 /**
@@ -135,7 +158,6 @@ async function readVisibleModeState(cwd: string, skill: string, sessionId: strin
  * absent so a handoff-required planning skill (deep-interview/ralplan) keeps
  * blocking through its handoff/ask window until it is demoted or cleared.
  */
-const WORKFLOW_FINISHED_PHASES = new Set(["complete", "completed", "failed", "cancelled", "canceled", "inactive"]);
 
 function entryMatchesContext(entry: SkillActiveEntry, sessionId?: string, threadId?: string): boolean {
 	if (sessionId && entry.session_id && entry.session_id !== sessionId) return false;
@@ -165,7 +187,7 @@ function isPlanningSkill(skill: string): skill is "deep-interview" | "ralplan" |
 function isBlockingPlanningPhase(skill: "deep-interview" | "ralplan" | "ultragoal", phase: string): boolean {
 	const normalized = phase.trim().toLowerCase();
 	if (skill === "ultragoal") return normalized === "goal-planning";
-	return !WORKFLOW_FINISHED_PHASES.has(normalized);
+	return !getSkillManifest(skill).stopReleasingPhases.includes(normalized);
 }
 
 interface ActivePlanningSkill {
@@ -219,10 +241,13 @@ async function getActivePlanningSkill(
 	cwd: string,
 	sessionId?: string,
 	threadId?: string,
+	context?: WorkflowGuardContext,
 ): Promise<ActivePlanningSkill | null> {
-	const resolvedSessionId = await resolveBoundarySessionId(cwd, sessionId);
+	const guardContext = context ?? (await readWorkflowGuardContext(cwd, { sessionId, threadId }));
+	const resolvedSessionId = guardContext.sessionId;
 	if (!resolvedSessionId) return null;
-	const skillState = await readVisibleSkillActiveState(cwd, resolvedSessionId, { tier: "security" });
+	const skillState = guardContext.activeState;
+
 	if (!skillState) return null;
 	const activeEntries = listActiveSkills(skillState).filter(entry =>
 		entryMatchesContext(entry, resolvedSessionId, threadId),
@@ -230,7 +255,8 @@ async function getActivePlanningSkill(
 	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, resolvedSessionId);
+	const modeState = guardContext.modeStates.get(current.skill) ?? null;
+
 	if (!modeState) return null;
 	if (modeState.active !== true) return null;
 	if (!modeStateMatchesContext(modeState, resolvedSessionId, threadId)) return null;
@@ -558,23 +584,25 @@ async function planningBlockedTargets(cwd: string, targets: ExtractedTargets): P
 	}
 	return blocked;
 }
-export async function assertDeepInterviewMutationRawPathsAllowed(input: {
+export async function assertWorkflowMutationRawPathsAllowed(input: {
 	cwd: string;
 	sessionId?: string;
 	threadId?: string;
 	rawPaths: string[];
 	forceOverride?: boolean;
+	guardContext?: WorkflowGuardContext;
 }): Promise<void> {
 	const targets: ExtractedTargets = { paths: input.rawPaths, unknown: input.rawPaths.length === 0 };
-	// Always-on `.gjc/**` runtime-owned block, in parity with getDeepInterviewMutationDecision
-	// and ahead of forceOverride: a deferred ast_edit apply must not reach `.gjc/**` either.
+	// Always-on `.gjc/**` runtime-owned block, ahead of forceOverride.
+	// A deferred ast_edit apply must not reach `.gjc/**` either.
 	if (hasBlockedGjcTarget(input.cwd, targets)) {
 		const stateSkill = firstBlockedWorkflowStateSkill(input.cwd, targets);
 		const command = stateSkill ? sanctionedWorkflowStateCommand(stateSkill) : "gjc <workflow-command>";
 		throw new ToolError(`${WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE}\nUse: ${command}`);
 	}
 	if (input.forceOverride) return;
-	const planning = await getActivePlanningSkill(input.cwd, input.sessionId, input.threadId);
+	const planning = await getActivePlanningSkill(input.cwd, input.sessionId, input.threadId, input.guardContext);
+
 	if (!planning) return;
 	const message = planningPhaseBlockMessage(planning.skill);
 	if (input.rawPaths.length === 0) throw new ToolError(message);
@@ -582,9 +610,9 @@ export async function assertDeepInterviewMutationRawPathsAllowed(input: {
 	if (blocked.length > 0) throw new ToolError(message);
 }
 
-export async function getDeepInterviewMutationDecision(
-	input: DeepInterviewMutationGuardInput,
-): Promise<DeepInterviewMutationDecision> {
+export async function getWorkflowMutationDecision(
+	input: WorkflowMutationGuardInput,
+): Promise<WorkflowMutationDecision> {
 	if (!BLOCKED_TOOL_NAMES.has(input.tool.name)) return { blocked: false, targets: [] };
 	const targets = extractTargets(input.tool, input.args);
 	if (input.tool.name !== "bash" && input.enforceWorkflowState !== false && hasBlockedGjcTarget(input.cwd, targets)) {
@@ -598,7 +626,7 @@ export async function getDeepInterviewMutationDecision(
 			command,
 		};
 	}
-	const planning = await getActivePlanningSkill(input.cwd, input.sessionId, input.threadId);
+	const planning = await getActivePlanningSkill(input.cwd, input.sessionId, input.threadId, input.guardContext);
 	if (!planning) {
 		return { blocked: false, targets: [] };
 	}
@@ -627,17 +655,7 @@ export async function getDeepInterviewMutationDecision(
 	};
 }
 
-export async function assertDeepInterviewMutationAllowed(input: DeepInterviewMutationGuardInput): Promise<void> {
-	const decision = await getDeepInterviewMutationDecision(input);
+export async function assertWorkflowMutationAllowed(input: WorkflowMutationGuardInput): Promise<void> {
+	const decision = await getWorkflowMutationDecision(input);
 	if (decision.blocked) throw new ToolError(decision.message ?? DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE);
 }
-
-/*
- * Generic cross-workflow names for this planning-phase mutation guard. The guard
- * now governs deep-interview, ralplan, and ultragoal goal-planning, so new
- * callers SHOULD use these names; the `*DeepInterview*` exports above remain as
- * compatibility aliases (and are still what the test-suite imports).
- */
-export const getWorkflowMutationDecision = getDeepInterviewMutationDecision;
-export const assertWorkflowMutationAllowed = assertDeepInterviewMutationAllowed;
-export const assertWorkflowMutationRawPathsAllowed = assertDeepInterviewMutationRawPathsAllowed;

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

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { activeSnapshotPath, assertNonEmptyGjcSessionId, modeStatePath } from "../gjc-runtime/session-layout";
 import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill, SKILL_ACTIVE_STATE_FILE } from "./active-state";
 import { WORKFLOW_STATE_RECEIPT_FRESH_MS, WORKFLOW_STATE_RECEIPT_VERSION } from "./workflow-state-version";
 
@@ -51,57 +52,21 @@ export interface AuditEntry {
 	paths: string[];
 }
 
-function safeString(value: unknown): string {
-	return typeof value === "string" ? value : "";
-}
-
-function encodePathSegment(value: string): string {
-	return encodeURIComponent(value).replaceAll(".", "%2E");
-}
-
 export function workflowModeStateFileName(skill: CanonicalGjcWorkflowSkill): string {
 	return `${skill}-state.json`;
 }
 
-export function workflowStateStoragePath(cwd: string, skill: CanonicalGjcWorkflowSkill, sessionId?: string): string {
-	const normalizedSessionId = safeString(sessionId).trim();
-	if (normalizedSessionId) {
-		return path.join(
-			cwd,
-			".gjc",
-			"state",
-			"sessions",
-			encodePathSegment(normalizedSessionId),
-			workflowModeStateFileName(skill),
-		);
-	}
-	return path.join(cwd, ".gjc", "state", workflowModeStateFileName(skill));
-}
-
-export function workflowActiveStatePath(cwd: string, sessionId?: string): string {
-	const normalizedSessionId = safeString(sessionId).trim();
-	if (normalizedSessionId) {
-		return path.join(
-			cwd,
-			".gjc",
-			"state",
-			"sessions",
-			encodePathSegment(normalizedSessionId),
-			SKILL_ACTIVE_STATE_FILE,
-		);
-	}
-	return path.join(cwd, ".gjc", "state", SKILL_ACTIVE_STATE_FILE);
-}
-
 export function buildWorkflowStateReceipt(input: {
 	cwd: string;
 	skill: CanonicalGjcWorkflowSkill;
 	owner: WorkflowStateMutationOwner;
 	command: string;
-	sessionId?: string;
+	sessionId: string;
 	nowIso?: string;
 	mutationId?: string;
 }): WorkflowStateReceipt {
+	assertNonEmptyGjcSessionId(input.sessionId, "buildWorkflowStateReceipt");
+	const cwd = path.resolve(input.cwd);
 	const mutatedAt = input.nowIso ?? new Date().toISOString();
 	const freshUntil = new Date(Date.parse(mutatedAt) + WORKFLOW_STATE_RECEIPT_FRESH_MS).toISOString();
 	return {
@@ -109,8 +74,8 @@ export function buildWorkflowStateReceipt(input: {
 		skill: input.skill,
 		owner: input.owner,
 		command: input.command,
-		state_path: workflowActiveStatePath(input.cwd, input.sessionId),
-		storage_path: workflowStateStoragePath(input.cwd, input.skill, input.sessionId),
+		state_path: activeSnapshotPath(cwd, input.sessionId),
+		storage_path: modeStatePath(cwd, input.sessionId, input.skill),
 		mutated_at: mutatedAt,
 		fresh_until: freshUntil,
 		status: "fresh",

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

@@ -18,12 +18,17 @@ import {
 	formatModelSelectorValue,
 	parseModelPattern,
 	parseModelString,
+	splitSelectorThinkingSuffix,
 } from "../config/model-resolver";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../discovery/helpers.js";
 import { resolveMemoryBackend } from "../memory-backend";
 import { DynamicBorder } from "../modes/components/dynamic-border";
 import { theme } from "../modes/theme/theme";
-import type { InteractiveModeContext } from "../modes/types";
+import {
+	type ComposerSubmissionOptions,
+	canApplyComposerSubmission,
+	type InteractiveModeContext,
+} from "../modes/types";
 import {
 	buildNotificationStatusReport,
 	checkNotificationHealth,
@@ -62,7 +67,13 @@ import type {
 export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 
 /** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
-export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
+export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime & {
+	composer?: ComposerSubmissionOptions;
+};
+
+function canClearComposer(runtime: BuiltinSlashCommandRuntime): boolean {
+	return canApplyComposerSubmission(runtime.composer, runtime.ctx.editor);
+}
 
 const PET_COMMAND_OPTIONS: ReadonlyArray<{ name: string; mode: PetMode; description: string }> = [
 	{ name: "off", mode: "off", description: "Hide the pet" },
@@ -243,12 +254,9 @@ function parseModelCommandArgs(args: string): ParsedModelCommandArgs {
 
 function splitExplicitThinkingSelector(selector: string): { baseSelector: string; thinkingLevel?: ThinkingLevel } {
 	const trimmed = selector.trim();
-	const colonIndex = trimmed.lastIndexOf(":");
-	if (colonIndex === -1) {
-		return { baseSelector: trimmed };
-	}
-	const thinkingLevel = parseThinkingLevel(trimmed.slice(colonIndex + 1));
-	return thinkingLevel ? { baseSelector: trimmed.slice(0, colonIndex), thinkingLevel } : { baseSelector: trimmed };
+	const { selector: baseSelector, thinkingLevel } = splitSelectorThinkingSuffix(trimmed);
+	// Preserve the whole selector when the trailing suffix is not a valid thinking level.
+	return thinkingLevel ? { baseSelector, thinkingLevel } : { baseSelector: trimmed };
 }
 
 interface ModelCommandSelection {
@@ -625,7 +633,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			// — including the first-time `/goal set <objective>` case where goal
 			// mode was not yet active. A previous `wasGoalModeEnabled` guard dropped
 			// that first-time case from history (up/down-arrow recall).
-			await runtime.ctx.handleGoalModeCommand(command.args || undefined);
+			await runtime.ctx.goalModeController.handleCommand(command.args || undefined);
 			if (command.args) {
 				runtime.ctx.editor.addToHistory(command.text);
 			}
@@ -1048,6 +1056,20 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "transcript",
+		description: "Browse the current session transcript",
+		acpDescription: "Browse the current session transcript",
+		handle: async (_command, runtime) => {
+			await runtime.output("Transcript browsing is available in the interactive TUI.");
+			return commandConsumed();
+		},
+		handleTui: (_command, runtime) => {
+			if (runtime.ctx.isTranscriptViewerOpen()) return;
+			runtime.ctx.showTranscriptViewer();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "context",
 		description: "Show active context token usage breakdown",
@@ -1446,6 +1468,15 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "sessions",
+		priority: 91,
+		description: "Show all persisted sessions (read-only)",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showSessionsDashboard();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "btw",
 		description: "Ask an ephemeral side question using the current session context",
@@ -1688,7 +1719,9 @@ export async function executeBuiltinSlashCommand(
 		const diagnostic = formatUnknownBuiltinSlashCommandDiagnostic(parsed.name);
 		if (!diagnostic) return false;
 		runtime.ctx.showError(diagnostic);
-		runtime.ctx.editor.setText("");
+		if (canClearComposer(runtime)) {
+			runtime.ctx.editor.setText("");
+		}
 		return true;
 	}
 	if (parsed.args.length > 0 && !command.allowArgs) {
@@ -1703,7 +1736,9 @@ export async function executeBuiltinSlashCommand(
 		const ctx = runtime.ctx;
 		const adapted = toSlashCommandRuntime(runtime);
 		const result = await command.handle(parsed, adapted);
-		ctx.editor.setText("");
+		if (canClearComposer(runtime)) {
+			ctx.editor.setText("");
+		}
 		if (result && typeof result === "object" && "prompt" in result) return result.prompt;
 		return true;
 	}