@gajae-code/coding-agent 0.12.8 → 0.12.11

package/src/session/internal/native-publish-outcome.ts

@@ -16,6 +16,8 @@ export type NativePublishOperation = "direct_rename" | "retained_file" | "retain
 
 export type NativePublishPrimitive =
 	| "renameat2_noreplace"
+	| "linkat_noreplace"
+	| "mkdirat_renameat_noreplace"
 	| "renameatx_np_excl"
 	| "windows_rename_noreplace"
 	| "unsupported"
@@ -24,6 +26,7 @@ export type NativePublishPhase =
 	| "preflight"
 	| "file_sync"
 	| "rename"
+	| "source_unlink"
 	| "source_parent_sync"
 	| "destination_parent_sync"
 	| "terminal_identity"
@@ -83,6 +86,8 @@ const reasons = new Set<NativePublishReason>([
 ]);
 const primitives = new Set<NativePublishPrimitive>([
 	"renameat2_noreplace",
+	"linkat_noreplace",
+	"mkdirat_renameat_noreplace",
 	"renameatx_np_excl",
 	"windows_rename_noreplace",
 	"unsupported",
@@ -92,6 +97,7 @@ const phases = new Set<NativePublishPhase>([
 	"preflight",
 	"file_sync",
 	"rename",
+	"source_unlink",
 	"source_parent_sync",
 	"destination_parent_sync",
 	"terminal_identity",
@@ -204,7 +210,7 @@ function legalOutcome(outcome: NativePublishOutcome): boolean {
 		((outcome.reason === "durability_not_provable" &&
 			["file_sync", "source_parent_sync", "destination_parent_sync"].includes(outcome.phase)) ||
 			(outcome.reason === "identity_violation" && outcome.phase === "terminal_identity") ||
-			(outcome.reason === "io_failure" && outcome.phase === "terminal_identity"))
+			(outcome.reason === "io_failure" && ["source_unlink", "terminal_identity"].includes(outcome.phase)))
 	);
 }
 
@@ -247,8 +253,12 @@ export function classifyNativePublishOutcome(
 	const outcome = value as unknown as NativePublishOutcome;
 	if (!legalOutcome(outcome)) return malformed;
 	if (operation === "direct_rename") return outcome;
+	const retainedPrimitiveValid =
+		operation === "retained_file"
+			? outcome.primitive === "renameat2_noreplace" || outcome.primitive === "linkat_noreplace"
+			: outcome.primitive === "renameat2_noreplace" || outcome.primitive === "mkdirat_renameat_noreplace";
 	if (
-		outcome.primitive !== "renameat2_noreplace" ||
+		!retainedPrimitiveValid ||
 		(outcome.ok && (!outcome.identity || outcome.durabilityState !== "proven" || outcome.phase !== "complete"))
 	)
 		return malformed;

package/src/session/session-manager.ts

@@ -899,6 +899,7 @@ export interface ResumeSessionIdentity {
 	size: number;
 	mtimeMs: number;
 	mtimeNs: bigint;
+	ctimeNs?: bigint;
 	sha256: string;
 }
 
@@ -918,6 +919,21 @@ export interface ResumeTailError {
 }
 
 export type SessionDirectoryMigrationPolicy = ManagedMigrationPolicy;
+export type SessionAppendPersistenceFailurePhase = "current_append" | "prior_failure";
+
+export class SessionAppendPersistenceError extends Error {
+	readonly phase: SessionAppendPersistenceFailurePhase;
+	readonly entryId: string;
+	readonly persistenceError: Error;
+
+	constructor(phase: SessionAppendPersistenceFailurePhase, entryId: string, persistenceError: Error) {
+		super(persistenceError.message, { cause: persistenceError });
+		this.name = "SessionAppendPersistenceError";
+		this.phase = phase;
+		this.entryId = entryId;
+		this.persistenceError = persistenceError;
+	}
+}
 
 export class SessionManagedStorageError extends Error {
 	readonly code = "managed_storage_unsupported";
@@ -2161,6 +2177,7 @@ function sameResumeIdentity(left: ResumeSessionIdentity, right: ResumeSessionIde
 		left.size === right.size &&
 		left.mtimeMs === right.mtimeMs &&
 		left.mtimeNs === right.mtimeNs &&
+		(left.ctimeNs === undefined || right.ctimeNs === undefined || left.ctimeNs === right.ctimeNs) &&
 		left.sha256 === right.sha256
 	);
 }
@@ -2174,7 +2191,8 @@ function sameResumeStat(left: SessionStorageStat, right: SessionStorageStat): bo
 		left.nlink === right.nlink &&
 		left.size === right.size &&
 		left.mtimeMs === right.mtimeMs &&
-		left.mtimeNs === right.mtimeNs
+		left.mtimeNs === right.mtimeNs &&
+		left.ctimeNs === right.ctimeNs
 	);
 }
 
@@ -2372,6 +2390,7 @@ function inspectResumeSessionFile(
 			size: snapshot.size,
 			mtimeMs: snapshot.mtimeMs,
 			mtimeNs: snapshot.mtimeNs,
+			ctimeNs: snapshot.ctimeNs,
 			sha256: crypto.createHash("sha256").update(bytes).digest("hex"),
 		};
 		return { identity, content: bytes, entries, context, migrationApplied };
@@ -2380,6 +2399,46 @@ function inspectResumeSessionFile(
 	}
 }
 
+function fsyncResumeSessionIdentity(expected: ResumeSessionIdentity): void {
+	const fd = fs.openSync(expected.canonicalPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+	try {
+		const before = fs.fstatSync(fd, { bigint: true });
+		if (
+			before.dev !== expected.dev ||
+			before.ino !== expected.ino ||
+			(expected.nlink !== undefined && before.nlink !== expected.nlink) ||
+			Number(before.size) !== expected.size ||
+			before.mtimeNs !== expected.mtimeNs ||
+			(expected.ctimeNs !== undefined && before.ctimeNs !== expected.ctimeNs)
+		) {
+			throw new Error("session_persistence_recovery_identity_mismatch");
+		}
+		fs.fsyncSync(fd);
+		const after = fs.fstatSync(fd, { bigint: true });
+		const named = fs.lstatSync(expected.canonicalPath, { bigint: true });
+		if (
+			after.dev !== before.dev ||
+			after.ino !== before.ino ||
+			after.nlink !== before.nlink ||
+			after.size !== before.size ||
+			after.mtimeNs !== before.mtimeNs ||
+			after.ctimeNs !== before.ctimeNs ||
+			named.dev !== after.dev ||
+			named.ino !== after.ino ||
+			named.nlink !== after.nlink
+		) {
+			throw new Error("session_persistence_recovery_identity_mismatch");
+		}
+	} finally {
+		fs.closeSync(fd);
+	}
+	const parentFd = fs.openSync(path.dirname(expected.canonicalPath), fs.constants.O_RDONLY | fs.constants.O_DIRECTORY);
+	try {
+		fs.fsyncSync(parentFd);
+	} finally {
+		fs.closeSync(parentFd);
+	}
+}
 /** Revalidate previously parsed authority without another decode, parse, migration, or context build. */
 function revalidateResumeSessionIdentity(
 	filePath: string,
@@ -2410,6 +2469,7 @@ function revalidateResumeSessionIdentity(
 		size: snapshot.stat.size,
 		mtimeMs: snapshot.stat.mtimeMs,
 		mtimeNs: snapshot.stat.mtimeNs,
+		ctimeNs: snapshot.stat.ctimeNs,
 		sha256: crypto.createHash("sha256").update(snapshot.bytes).digest("hex"),
 	};
 	return sameResumeIdentity(expected, observed) ? { kind: "valid" } : { kind: "error", reason: "identity-mismatch" };
@@ -4751,7 +4811,9 @@ export class SessionManager {
 	#recoveryPromotionTranscriptPath: string | undefined;
 	#memoryGuardParticipantIngressToken: symbol | undefined;
 	#fileEntries: FileEntry[] = [];
-	#pendingStrictAdoption: { canonicalPath: string; identity: ResumeSessionIdentity } | undefined;
+	#pendingStrictAdoption:
+		| { canonicalPath: string; identity: ResumeSessionIdentity; inspection?: ResumeInspectionSnapshot }
+		| undefined;
 	#byId: Map<string, SessionEntry> = new Map();
 	#labelsById: Map<string, string> = new Map();
 	#leafId: string | null = null;
@@ -5501,11 +5563,14 @@ export class SessionManager {
 			if (strictAdoption && resolvedSessionFile === strictAdoption.canonicalPath) {
 				const inspected = inspectResumeSessionFile(resolvedSessionFile, this.storage);
 				if ("kind" in inspected || !sameResumeIdentity(strictAdoption.identity, inspected.identity))
-					throw new Error("Prepared managed session changed before strict adoption.");
+					throw new Error("Prepared session changed before strict adoption.");
 			}
 			let entries: FileEntry[];
 			let candidateMigrationApplied = false;
-			if (this.storage.existsSync(resolvedSessionFile)) {
+			if (strictAdoption?.inspection && resolvedSessionFile === strictAdoption.canonicalPath) {
+				entries = strictAdoption.inspection.entries;
+				candidateMigrationApplied = strictAdoption.inspection.migrationApplied;
+			} else if (this.storage.existsSync(resolvedSessionFile)) {
 				const inspected = inspectResumeSessionFile(resolvedSessionFile, this.storage);
 				if ("kind" in inspected) throw new Error(`Could not switch session: ${inspected.reason}`);
 				entries = inspected.entries;
@@ -5516,7 +5581,7 @@ export class SessionManager {
 			if (strictAdoption) {
 				const inspected = inspectResumeSessionFile(resolvedSessionFile, this.storage);
 				if ("kind" in inspected || !sameResumeIdentity(strictAdoption.identity, inspected.identity))
-					throw new Error("Prepared managed session changed during strict adoption.");
+					throw new Error("Prepared session changed during strict adoption.");
 			}
 			if (entries.length > 0) {
 				const header = entries.find(entry => entry.type === "session") as SessionHeader | undefined;
@@ -5541,6 +5606,13 @@ export class SessionManager {
 					prepared.dispose();
 					throw error;
 				}
+				if (strictAdoption) {
+					const inspected = inspectResumeSessionFile(resolvedSessionFile, this.storage);
+					if ("kind" in inspected || !sameResumeIdentity(strictAdoption.identity, inspected.identity)) {
+						prepared.dispose();
+						throw new Error("Prepared session changed before strict adoption commit.");
+					}
+				}
 				const previous = {
 					sessionId: this.#sessionId,
 					sessionName: this.#sessionName,
@@ -8265,13 +8337,31 @@ export class SessionManager {
 		this.#assertRecoveryHydrationWritable();
 		const normalizedEntry = normalizeSessionEntryForStorage(entry);
 		const residentEntry = this.#prepareEntryForCurrentResidentStore(normalizedEntry) as SessionEntry;
+		const previousLeafId = this.#leafId;
+		const priorPersistenceError = this.#persistError;
 		this.#fileEntries.push(residentEntry);
 		this.#byId.set(residentEntry.id, residentEntry);
 		this.#leafId = residentEntry.id;
 		this.#bumpEntryRevision();
 		this.#leafRevision++;
 		if (entry.type === "label") this.#labelRevision++;
-		this._persist(residentEntry);
+		try {
+			this._persist(residentEntry);
+		} catch (error) {
+			const removed = this.#fileEntries.pop();
+			if (removed !== residentEntry)
+				throw new Error("Session append rollback lost resident ordering.", { cause: error });
+			this.#byId.delete(residentEntry.id);
+			this.#leafId = previousLeafId;
+			this.#bumpEntryRevision();
+			this.#leafRevision++;
+			if (entry.type === "label") this.#labelRevision++;
+			throw new SessionAppendPersistenceError(
+				priorPersistenceError ? "prior_failure" : "current_append",
+				residentEntry.id,
+				this.#persistError ?? toError(error),
+			);
+		}
 		// Same validated, overflow-guarded aggregation as the resume path (#buildIndex): a
 		// malformed task-result or assistant usage shape reaching the append path must not
 		// crash or poison getUsageStatistics() either.
@@ -8513,6 +8603,50 @@ export class SessionManager {
 		this.#replayMetadataRevision++;
 	}
 
+	/**
+	 * Rehydrate the canonical transcript after a synchronous persistence failure.
+	 *
+	 * The failed append may have committed before reporting an uncertain outcome,
+	 * so callers must not clear the sticky error or retry against the resident
+	 * branch. Reloading the exact session file is the only supported recovery
+	 * boundary for both managed and explicit persistent destinations.
+	 */
+	async recoverPersistenceFailure(): Promise<void> {
+		const persistenceError = this.#persistError;
+		if (!persistenceError) return;
+		if (!this.#sessionFile) throw persistenceError;
+		const sessionFile = this.#sessionFile;
+		try {
+			await this.#closePersistWriter();
+		} catch {
+			// A writer reports its prior write failure after a confirmed close. A
+			// second close clears that terminal writer; retryable close failures are
+			// genuinely re-dispatched and still fail if the descriptor cannot settle.
+		}
+		await this.#closePersistWriter();
+		const inspected = inspectResumeSessionFile(sessionFile, this.storage);
+		if ("kind" in inspected) throw persistenceError;
+		try {
+			fsyncResumeSessionIdentity(inspected.identity);
+		} catch {
+			throw persistenceError;
+		}
+		const durable = inspectResumeSessionFile(sessionFile, this.storage);
+		if ("kind" in durable || !sameResumeIdentity(inspected.identity, durable.identity)) {
+			throw persistenceError;
+		}
+		const adoption = {
+			canonicalPath: durable.identity.canonicalPath,
+			identity: durable.identity,
+			inspection: durable,
+		};
+		this.#pendingStrictAdoption = adoption;
+		try {
+			await this.setSessionFile(durable.identity.canonicalPath);
+		} finally {
+			if (this.#pendingStrictAdoption === adoption) this.#pendingStrictAdoption = undefined;
+		}
+	}
 	/**
 	 * Rewrite the session file after in-place entry updates.
 	 * Use sparingly (e.g., pruning old tool outputs).

package/src/session/session-storage.ts

@@ -28,6 +28,7 @@ export interface SessionStorageStat {
 	size: number;
 	mtimeMs: number;
 	mtimeNs: bigint;
+	ctimeNs: bigint;
 	mtime: Date;
 	isFile: boolean;
 }
@@ -47,6 +48,7 @@ function statFromNode(stats: fs.BigIntStats): SessionStorageStat {
 		size: Number(stats.size),
 		mtimeMs: Number(stats.mtimeMs),
 		mtimeNs: stats.mtimeNs,
+		ctimeNs: stats.ctimeNs,
 		mtime: stats.mtime,
 		isFile: stats.isFile(),
 	};
@@ -1624,6 +1626,7 @@ export class MemorySessionStorage implements SessionStorage {
 			size: entry.content.byteLength,
 			mtimeMs: entry.mtimeMs,
 			mtimeNs: BigInt(entry.mtimeMs) * 1_000_000n,
+			ctimeNs: BigInt(entry.mtimeMs) * 1_000_000n,
 			mtime: new Date(entry.mtimeMs),
 			isFile: true,
 		};

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

@@ -417,6 +417,9 @@ function modelSelectionUsage(runtime: SlashCommandRuntime, currentModelLine?: st
 		.join("\n\n");
 }
 
+/** Opt into the paste-a-code OAuth login for browsers that cannot reach this machine. */
+const MANUAL_LOGIN_FLAG = "--manual";
+
 const EFFORT_COMMAND_INPUT_HINT = "[inherit|off|minimal|low|medium|high|xhigh|max]";
 const EFFORT_COMMAND_ACCEPTED_VALUES = ["inherit", "off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 
@@ -1364,20 +1367,45 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "login",
 		description: "Login with OAuth provider",
-		inlineHint: "[provider|redirect URL]",
+		inlineHint: "[provider|redirect URL] [--manual]",
 		allowArgs: true,
 		handleTui: (command, runtime) => {
 			const manualInput = runtime.ctx.oauthManualInput;
 			const args = command.args.trim();
+			const pendingLoginMessage = (): string => {
+				const pendingProvider = manualInput.pendingProviderId;
+				return pendingProvider
+					? `OAuth login already in progress for ${pendingProvider}. Paste the redirect URL with /login <url>.`
+					: "OAuth login already in progress. Paste the redirect URL with /login <url>.";
+			};
 			if (args.length > 0) {
+				const tokens = args.split(/\s+/);
+				// `--manual` is resolved before the paste fallback below, otherwise
+				// `/login anthropic --manual` would be submitted as an authorization code.
+				if (tokens.includes(MANUAL_LOGIN_FLAG)) {
+					const rest = tokens.filter(token => token !== MANUAL_LOGIN_FLAG);
+					const requestedProvider = rest.length === 1 ? rest[0] : undefined;
+					const manualProvider = requestedProvider
+						? getOAuthProviders().find(provider => provider.id === requestedProvider)
+						: undefined;
+					if (!manualProvider) {
+						runtime.ctx.showWarning(`Usage: /login <provider> ${MANUAL_LOGIN_FLAG}`);
+						runtime.ctx.editor.setText("");
+						return;
+					}
+					if (manualInput.hasPending()) {
+						runtime.ctx.showWarning(pendingLoginMessage());
+						runtime.ctx.editor.setText("");
+						return;
+					}
+					void runtime.ctx.showOAuthSelector("login", manualProvider.id, { manualCode: true });
+					runtime.ctx.editor.setText("");
+					return;
+				}
 				const matchedProvider = getOAuthProviders().find(provider => provider.id === args);
 				if (matchedProvider) {
 					if (manualInput.hasPending()) {
-						const pendingProvider = manualInput.pendingProviderId;
-						const message = pendingProvider
-							? `OAuth login already in progress for ${pendingProvider}. Paste the redirect URL with /login <url>.`
-							: "OAuth login already in progress. Paste the redirect URL with /login <url>.";
-						runtime.ctx.showWarning(message);
+						runtime.ctx.showWarning(pendingLoginMessage());
 						runtime.ctx.editor.setText("");
 						return;
 					}
@@ -1396,11 +1424,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			}
 
 			if (manualInput.hasPending()) {
-				const provider = manualInput.pendingProviderId;
-				const message = provider
-					? `OAuth login already in progress for ${provider}. Paste the redirect URL with /login <url>.`
-					: "OAuth login already in progress. Paste the redirect URL with /login <url>.";
-				runtime.ctx.showWarning(message);
+				runtime.ctx.showWarning(pendingLoginMessage());
 				runtime.ctx.editor.setText("");
 				return;
 			}

package/src/system-prompt.ts

@@ -245,10 +245,14 @@ function dedupeExactContextFiles(
 		// Keep the closest matching context entry when content is byte-for-byte identical.
 		lastIndexByContent.set(file.content, index);
 	}
-
 	return contextFiles.filter((file, index) => lastIndexByContent.get(file.content) === index);
 }
 
+export interface ProjectContextFilesResult {
+	contextFiles: Array<{ path: string; content: string; depth?: number }>;
+	warnings: string[];
+}
+
 /**
  * Load all context files using the capability API.
  * Returns {path, content, depth} entries for all discovered context files.
@@ -257,11 +261,10 @@ function dedupeExactContextFiles(
  * prominent. User-home files from foreign providers (`~/.claude/CLAUDE.md`,
  * `~/.codex/AGENTS.md`, …) stay excluded — only gjc's own user config applies.
  */
-export async function loadProjectContextFiles(
+export async function loadProjectContextFilesResult(
 	options: LoadContextFilesOptions = {},
-): Promise<Array<{ path: string; content: string; depth?: number }>> {
+): Promise<ProjectContextFilesResult> {
 	const resolvedCwd = options.cwd ?? getProjectDir();
-
 	const result = await loadCapability(contextFileCapability.id, { cwd: resolvedCwd });
 	const items = result.items as ContextFile[];
 
@@ -288,7 +291,17 @@ export async function loadProjectContextFiles(
 		return depthB - depthA;
 	});
 
-	return dedupeExactContextFiles([...userFiles, ...projectFiles]);
+	return {
+		contextFiles: dedupeExactContextFiles([...userFiles, ...projectFiles]),
+		warnings: result.warnings,
+	};
+}
+
+/** Load project context files without exposing discovery diagnostics. */
+export async function loadProjectContextFiles(
+	options: LoadContextFilesOptions = {},
+): Promise<Array<{ path: string; content: string; depth?: number }>> {
+	return (await loadProjectContextFilesResult(options)).contextFiles;
 }
 
 /**
@@ -386,10 +399,11 @@ export interface BuildSystemPromptOptions {
 	subagent?: boolean;
 }
 
-/** Result of building provider-facing system prompt messages. */
 export interface BuildSystemPromptResult {
 	/** Ordered system prompt blocks. Providers should preserve entries as distinct messages/blocks. */
 	systemPrompt: string[];
+	/** Context-file discovery warnings visible to SDK and session callers. */
+	warnings: string[];
 }
 export interface BuildVolatileProjectContextOptions {
 	cwd?: string;
@@ -421,7 +435,7 @@ export function buildVolatileProjectContext(options: BuildVolatileProjectContext
 /** Build the system prompt with tools, guidelines, and context */
 export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}): Promise<BuildSystemPromptResult> {
 	if ($env.NULL_PROMPT === "true") {
-		return { systemPrompt: [] };
+		return { systemPrompt: [], warnings: [] };
 	}
 
 	const {
@@ -448,7 +462,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		resolvedCustomPrompt: undefined as string | undefined,
 		resolvedAppendPrompt: undefined as string | undefined,
 		systemPromptCustomization: null as string | null,
-		contextFiles: dedupeExactContextFiles(providedContextFiles ?? []),
+		contextFiles: { contextFiles: [] as Array<{ path: string; content: string; depth?: number }>, warnings: [] },
 		workspaceTree: {
 			rootPath: resolvedCwd,
 			rendered: "",
@@ -490,8 +504,8 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		cwd: resolvedCwd,
 	});
 	const contextFilesPromise = providedContextFiles
-		? Promise.resolve(providedContextFiles)
-		: logger.time("loadProjectContextFiles", loadProjectContextFiles, { cwd: resolvedCwd });
+		? Promise.resolve({ contextFiles: providedContextFiles, warnings: [] })
+		: logger.time("loadProjectContextFiles", loadProjectContextFilesResult, { cwd: resolvedCwd });
 	const workspaceTreePromise =
 		providedWorkspaceTree !== undefined
 			? Promise.resolve(providedWorkspaceTree)
@@ -499,7 +513,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 					buildWorkspaceTree(resolvedCwd, { timeoutMs: SYSTEM_PROMPT_PREP_TIMEOUT_MS }),
 				);
 
-	const [resolvedCustomPrompt, resolvedAppendPrompt, systemPromptCustomization, contextFiles, workspaceTree] =
+	const [resolvedCustomPrompt, resolvedAppendPrompt, systemPromptCustomization, contextFileResult, workspaceTree] =
 		await Promise.all([
 			withDeadline(
 				"customPrompt",
@@ -516,11 +530,10 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 				systemPromptCustomizationPromise,
 				prepDefaults.systemPromptCustomization,
 			),
-			withDeadline("loadProjectContextFiles", contextFilesPromise, prepDefaults.contextFiles).then(
-				dedupeExactContextFiles,
-			),
+			withDeadline("loadProjectContextFiles", contextFilesPromise, prepDefaults.contextFiles),
 			withDeadline("buildWorkspaceTree", workspaceTreePromise, prepDefaults.workspaceTree),
 		]);
+	const contextFiles = dedupeExactContextFiles(contextFileResult.contextFiles);
 	const agentsMdFiles = Array.from(new Set(workspaceTree.agentsMdFiles)).sort().slice(0, AGENTS_MD_LIMIT);
 
 	if (timedOut.length > 0) {
@@ -628,5 +641,5 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		systemPrompt.push(pluginAppendices.trim());
 	}
 
-	return { systemPrompt };
+	return { systemPrompt, warnings: contextFileResult.warnings };
 }

package/src/tools/bash.ts

@@ -982,8 +982,10 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			}
 		}
 
+		const activeModel = this.session.model;
 		const composerPolicy = checkComposerBashPolicy({
-			modelId: this.session.getActiveModelString?.() ?? this.session.getModelString?.() ?? this.session.model?.id,
+			modelId: this.session.getActiveModelString?.() ?? this.session.getModelString?.() ?? activeModel?.id,
+			provider: activeModel?.provider,
 			commands: rawCommand === command ? [command] : [rawCommand, command],
 		});
 		if (!composerPolicy.allowed) {

package/src/tools/composer-bash-policy.ts

@@ -1,7 +1,11 @@
-import { isComposerHarnessModel } from "@gajae-code/ai/providers/composer-discipline";
+import {
+	type ComposerBashPolicyToolSurface,
+	formatComposerBashPolicyError,
+	isComposerHarnessModel,
+} from "@gajae-code/ai/providers/composer-discipline";
 
-export const COMPOSER_BASH_POLICY_ERROR =
-	"Composer bash policy blocked repository file I/O. Use find, search, read, and edit tools for file discovery, file inspection, and file mutation.";
+export const COMPOSER_BASH_POLICY_ERROR = formatComposerBashPolicyError("generic");
+export const CURSOR_COMPOSER_BASH_POLICY_ERROR = formatComposerBashPolicyError("cursor");
 
 type ComposerBashPolicyResult =
 	| { allowed: true }
@@ -9,6 +13,7 @@ type ComposerBashPolicyResult =
 			allowed: false;
 			reason: string;
 			message: string;
+			surface: ComposerBashPolicyToolSurface;
 	  };
 
 const BLOCK_PATTERNS: Array<{ id: string; pattern: RegExp }> = [
@@ -77,19 +82,30 @@ export function isComposerBashPolicyModel(modelId: string | undefined): boolean
 	return Boolean(modelId && isComposerHarnessModel(modelId));
 }
 
+export function resolveComposerBashPolicyToolSurface(input: {
+	modelId?: string;
+	provider?: string;
+}): ComposerBashPolicyToolSurface {
+	if (input.provider?.toLowerCase() === "cursor") return "cursor";
+	return /(?:^|[/:._-])cursor(?:[/:._-]|$)/i.test(input.modelId ?? "") ? "cursor" : "generic";
+}
+
 export function checkComposerBashPolicy(input: {
 	modelId?: string;
+	provider?: string;
 	commands: readonly string[];
 }): ComposerBashPolicyResult {
 	if (!isComposerBashPolicyModel(input.modelId)) return { allowed: true };
+	const surface = resolveComposerBashPolicyToolSurface(input);
+	const message = formatComposerBashPolicyError(surface);
 	for (const command of input.commands) {
 		for (const block of BLOCK_PATTERNS) {
 			if (block.pattern.test(command)) {
-				return { allowed: false, reason: block.id, message: COMPOSER_BASH_POLICY_ERROR };
+				return { allowed: false, reason: block.id, message, surface };
 			}
 		}
 		if (!isAllowedComposerTerminalCommand(command)) {
-			return { allowed: false, reason: "not-allowlisted", message: COMPOSER_BASH_POLICY_ERROR };
+			return { allowed: false, reason: "not-allowlisted", message, surface };
 		}
 	}
 	return { allowed: true };