@agi-cli/server 0.1.95 → 0.1.97

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.95",
+	"version": "0.1.97",
 	"description": "HTTP API server for AGI CLI",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,8 +29,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@agi-cli/sdk": "0.1.95",
-		"@agi-cli/database": "0.1.95",
+		"@agi-cli/sdk": "0.1.97",
+		"@agi-cli/database": "0.1.97",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/index.ts

@@ -228,7 +228,10 @@ export {
 	resolveAgentConfig,
 	defaultToolsForAgent,
 } from './runtime/agent-registry.ts';
-export { composeSystemPrompt } from './runtime/prompt.ts';
+export {
+	composeSystemPrompt,
+	type ComposedSystemPrompt,
+} from './runtime/prompt.ts';
 export {
 	AskServiceError,
 	handleAskRequest,

package/src/runtime/agent-registry.ts

@@ -317,7 +317,12 @@ export async function resolveAgentConfig(
 	const provider = normalizeProvider(entry?.provider);
 	const model = normalizeModel(entry?.model);
 	debugLog(`[agent] ${name} prompt source: ${promptSource}`);
-	debugLog(`[agent] ${name} prompt:\n${prompt}`);
+	debugLog(
+		`[agent] ${name} prompt summary: ${JSON.stringify({
+			length: prompt.length,
+			lines: prompt.split('\n').length,
+		})}`,
+	);
 	return {
 		name,
 		prompt,

package/src/runtime/history/tool-history-tracker.ts

@@ -0,0 +1,204 @@
+import { debugLog } from '../debug.ts';
+
+type ToolResultPart = {
+	type: string;
+	state?: string;
+	toolCallId?: string;
+	input?: unknown;
+	output?: unknown;
+	[key: string]: unknown;
+};
+
+type ToolResultInfo = {
+	toolName: string;
+	callId: string;
+	args: unknown;
+	result: unknown;
+};
+
+type TargetDescriptor = {
+	keys: string[];
+	summary: string;
+};
+
+type TrackedPart = {
+	part: ToolResultPart;
+	summary: string;
+	summarized: boolean;
+};
+
+export class ToolHistoryTracker {
+	private readonly targets = new Map<string, TrackedPart>();
+
+	register(part: ToolResultPart, info: ToolResultInfo) {
+		const descriptor = describeToolResult(info);
+		if (!descriptor) return;
+
+		const entry: TrackedPart = {
+			part,
+			summary: descriptor.summary,
+			summarized: false,
+		};
+
+		for (const key of descriptor.keys) {
+			const previous = this.targets.get(key);
+			if (previous && previous.part !== part) {
+				this.applySummary(previous);
+			}
+			this.targets.set(key, entry);
+		}
+	}
+
+	private applySummary(entry: TrackedPart) {
+		if (entry.summarized) return;
+		// Keep this entry as a tool result so the history still produces tool_result blocks.
+		entry.part.state = 'output-available';
+		entry.part.output = entry.summary;
+		(entry.part as { summaryText?: string }).summaryText = entry.summary;
+		delete (entry.part as { errorText?: unknown }).errorText;
+		delete (entry.part as { rawInput?: unknown }).rawInput;
+		delete (entry.part as { callProviderMetadata?: unknown })
+			.callProviderMetadata;
+		delete (entry.part as { providerMetadata?: unknown }).providerMetadata;
+		entry.summarized = true;
+		debugLog(`[history] summarized tool output -> ${entry.summary}`);
+	}
+}
+
+function describeToolResult(info: ToolResultInfo): TargetDescriptor | null {
+	const { toolName } = info;
+	switch (toolName) {
+		case 'read':
+			return describeRead(info);
+		case 'glob':
+		case 'grep':
+			return describePatternTool(info, toolName);
+		case 'write':
+			return describeWrite(info);
+		case 'apply_patch':
+			return describePatch(info);
+		default:
+			return null;
+	}
+}
+
+function describeRead(info: ToolResultInfo): TargetDescriptor | null {
+	const args = getRecord(info.args);
+	if (!args) return null;
+	const path = getString(args.path);
+	if (!path) return null;
+	const startLine = getNumber(args.startLine);
+	const endLine = getNumber(args.endLine);
+
+	let rangeLabel = 'entire file';
+	let rangeKey = 'all';
+	if (startLine !== undefined || endLine !== undefined) {
+		const start = startLine ?? 1;
+		const end = endLine ?? 'end';
+		rangeLabel = `lines ${start}–${end}`;
+		rangeKey = `${start}-${end}`;
+	}
+
+	const key = `read:${normalizePath(path)}:${rangeKey}`;
+	const summary = `[previous read] ${normalizePath(path)} (${rangeLabel})`;
+	return { keys: [key], summary };
+}
+
+function describePatternTool(
+	info: ToolResultInfo,
+	toolName: string,
+): TargetDescriptor | null {
+	const args = getRecord(info.args);
+	if (!args) return null;
+	const pattern =
+		getString(args.pattern) ??
+		getString(args.filePattern) ??
+		getString(args.path);
+	if (!pattern) return null;
+	const key = `${toolName}:${pattern}`;
+	const summary = `[previous ${toolName}] ${pattern}`;
+	return { keys: [key], summary };
+}
+
+function describeWrite(info: ToolResultInfo): TargetDescriptor | null {
+	const result = getRecord(info.result);
+	if (!result) return null;
+	const path = getString(result.path);
+	if (!path) return null;
+	const bytes = getNumber(result.bytes);
+	const sizeLabel =
+		typeof bytes === 'number' && Number.isFinite(bytes)
+			? `${bytes} bytes`
+			: 'unknown size';
+	const key = `write:${normalizePath(path)}`;
+	const summary = `[previous write] ${normalizePath(path)} (${sizeLabel})`;
+	return { keys: [key], summary };
+}
+
+function describePatch(info: ToolResultInfo): TargetDescriptor | null {
+	const result = getRecord(info.result);
+	if (!result) return null;
+
+	const files = new Set<string>();
+
+	const changes = getArray(result.changes);
+	if (changes) {
+		for (const change of changes) {
+			const changeObj = getRecord(change);
+			const filePath = changeObj && getString(changeObj.filePath);
+			if (filePath) files.add(normalizePath(filePath));
+		}
+	}
+
+	const artifact = getRecord(result.artifact);
+	if (artifact) {
+		const summary = getRecord(artifact.summary);
+		const summaryFiles = getArray(summary?.files);
+		if (summaryFiles) {
+			for (const item of summaryFiles) {
+				if (typeof item === 'string') files.add(normalizePath(item));
+				else {
+					const record = getRecord(item);
+					const value = record && getString(record.path);
+					if (value) files.add(normalizePath(value));
+				}
+			}
+		}
+	}
+
+	const fileList = Array.from(files);
+	const keys = fileList.length
+		? fileList.map((file) => `apply_patch:${file}`)
+		: [`apply_patch:${info.callId}`];
+
+	const summary =
+		fileList.length > 0
+			? `[previous patch] ${fileList.join(', ')}`
+			: '[previous patch] (unknown files)';
+
+	return { keys, summary };
+}
+
+function getRecord(value: unknown): Record<string, unknown> | null {
+	return value && typeof value === 'object' && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: null;
+}
+
+function getArray(value: unknown): unknown[] | null {
+	return Array.isArray(value) ? value : null;
+}
+
+function getString(value: unknown): string | null {
+	if (typeof value === 'string') return value;
+	return null;
+}
+
+function getNumber(value: unknown): number | undefined {
+	if (typeof value === 'number' && Number.isFinite(value)) return value;
+	return undefined;
+}
+
+function normalizePath(path: string): string {
+	return path.replace(/\\/g, '/');
+}

package/src/runtime/history-builder.ts

@@ -3,6 +3,7 @@ import type { getDb } from '@agi-cli/database';
 import { messages, messageParts } from '@agi-cli/database/schema';
 import { eq, asc } from 'drizzle-orm';
 import { debugLog } from './debug.ts';
+import { ToolHistoryTracker } from './history/tool-history-tracker.ts';
 
 /**
  * Builds the conversation history for a session from the database,
@@ -19,12 +20,14 @@ export async function buildHistoryMessages(
 		.orderBy(asc(messages.createdAt));
 
 	const ui: UIMessage[] = [];
+	const toolHistory = new ToolHistoryTracker();
 
 	for (const m of rows) {
 		if (m.role === 'assistant' && m.status !== 'complete') {
 			debugLog(
-				`[buildHistoryMessages] Skipping assistant message ${m.id} with status ${m.status}`,
+				`[buildHistoryMessages] Skipping assistant message ${m.id} with status ${m.status} (current turn still in progress)`,
 			);
+			logPendingToolParts(db, m.id);
 			continue;
 		}
 
@@ -103,13 +106,21 @@ export async function buildHistoryMessages(
 				// Skip error parts in history
 			}
 
+			const toolResultsById = new Map(
+				toolResults.map((result) => [result.callId, result]),
+			);
+
 			const hasIncompleteTools = toolCalls.some(
-				(call) => !toolResults.find((result) => result.callId === call.callId),
+				(call) => !toolResultsById.has(call.callId),
 			);
 
 			if (hasIncompleteTools) {
+				const pendingCalls = toolCalls
+					.filter((call) => !toolResultsById.has(call.callId))
+					.map((call) => `${call.name}#${call.callId}`)
+					.join(', ');
 				debugLog(
-					`[buildHistoryMessages] Incomplete tool calls for assistant message ${m.id}, pushing text only`,
+					`[buildHistoryMessages] Incomplete tool calls for assistant message ${m.id}, skipping tool data (pending: ${pendingCalls || 'unknown'})`,
 				);
 				if (assistantParts.length) {
 					ui.push({ id: m.id, role: 'assistant', parts: assistantParts });
@@ -122,47 +133,92 @@ export async function buildHistoryMessages(
 				if (call.name === 'finish') continue;
 
 				const toolType = `tool-${call.name}` as `tool-${string}`;
-				const result = toolResults.find((r) => r.callId === call.callId);
+				const result = toolResultsById.get(call.callId);
 
 				if (result) {
-					const outputStr = (() => {
-						const r = result.result;
-						if (typeof r === 'string') return r;
-						try {
-							return JSON.stringify(r);
-						} catch {
-							return String(r);
-						}
-					})();
-
-					assistantParts.push({
+					const part = {
 						type: toolType,
 						state: 'output-available',
 						toolCallId: call.callId,
 						input: call.args,
-						output: outputStr,
-					} as never);
+						output: (() => {
+							const r = result.result;
+							if (typeof r === 'string') return r;
+							try {
+								return JSON.stringify(r);
+							} catch {
+								return String(r);
+							}
+						})(),
+					};
+
+					toolHistory.register(part, {
+						toolName: call.name,
+						callId: call.callId,
+						args: call.args,
+						result: result.result,
+					});
+
+					assistantParts.push(part as never);
 				}
 			}
 
 			if (assistantParts.length) {
 				ui.push({ id: m.id, role: 'assistant', parts: assistantParts });
+			}
+		}
+	}
 
-				if (toolResults.length) {
-					const userParts: UIMessage['parts'] = toolResults.map((r) => {
-						const out =
-							typeof r.result === 'string'
-								? r.result
-								: JSON.stringify(r.result);
-						return { type: 'text', text: out };
+	return convertToModelMessages(ui);
+}
+
+async function logPendingToolParts(
+	db: Awaited<ReturnType<typeof getDb>>,
+	messageId: string,
+) {
+	try {
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, messageId))
+			.orderBy(asc(messageParts.index));
+
+		const pendingCalls: string[] = [];
+		for (const part of parts) {
+			if (part.type !== 'tool_call') continue;
+			try {
+				const obj = JSON.parse(part.content ?? '{}') as {
+					name?: string;
+					callId?: string;
+				};
+				if (obj.name && obj.callId) {
+					const resultExists = parts.some((candidate) => {
+						if (candidate.type !== 'tool_result') return false;
+						try {
+							const parsed = JSON.parse(candidate.content ?? '{}') as {
+								callId?: string;
+							};
+							return parsed.callId === obj.callId;
+						} catch {
+							return false;
+						}
 					});
-					if (userParts.length) {
-						ui.push({ id: m.id, role: 'user', parts: userParts });
+					if (!resultExists) {
+						pendingCalls.push(`${obj.name}#${obj.callId}`);
 					}
 				}
-			}
+			} catch {}
 		}
+		if (pendingCalls.length) {
+			debugLog(
+				`[buildHistoryMessages] Pending tool calls for assistant message ${messageId}: ${pendingCalls.join(', ')}`,
+			);
+		}
+	} catch (err) {
+		debugLog(
+			`[buildHistoryMessages] Failed to inspect pending tool calls for ${messageId}: ${
+				err instanceof Error ? err.message : String(err)
+			}`,
+		);
 	}
-
-	return convertToModelMessages(ui);
 }

package/src/runtime/message-service.ts

@@ -246,19 +246,23 @@ async function generateSessionTitle(args: {
 				},
 			];
 
-			debugLog('[TITLE_GEN] Using OAuth mode:');
-			debugLog(`[TITLE_GEN] System prompt (spoof): ${spoofPrompt}`);
-			debugLog(`[TITLE_GEN] User message (instructions + content):`);
-			debugLog(`[TITLE_GEN]   Instructions: ${titlePrompt}`);
-			debugLog(`[TITLE_GEN]   Content: ${promptText.substring(0, 100)}...`);
+			debugLog(
+				`[TITLE_GEN] Using OAuth mode (prompts: spoof:${provider}, title-generator, user-request)`,
+			);
+			debugLog(
+				`[TITLE_GEN] User content preview: ${promptText.substring(0, 100)}...`,
+			);
 		} else {
 			// API key mode: normal flow
 			system = titlePrompt;
 			messagesArray = [{ role: 'user', content: promptText }];
 
-			debugLog('[TITLE_GEN] Using API key mode:');
-			debugLog(`[TITLE_GEN] System prompt: ${system}`);
-			debugLog(`[TITLE_GEN] User message: ${promptText.substring(0, 100)}...`);
+			debugLog(
+				`[TITLE_GEN] Using API key mode (prompts: title-generator, user-request)`,
+			);
+			debugLog(
+				`[TITLE_GEN] User content preview: ${promptText.substring(0, 100)}...`,
+			);
 		}
 
 		debugLog('[TITLE_GEN] Calling generateText...');

package/src/runtime/prompt.ts

@@ -12,6 +12,12 @@ import ANTHROPIC_SPOOF_PROMPT from '@agi-cli/sdk/prompts/providers/anthropicSpoo
 };
 
 import { getTerminalManager } from '@agi-cli/sdk';
+
+export type ComposedSystemPrompt = {
+	prompt: string;
+	components: string[];
+};
+
 export async function composeSystemPrompt(options: {
 	provider: string;
 	model?: string;
@@ -22,9 +28,17 @@ export async function composeSystemPrompt(options: {
 	includeEnvironment?: boolean;
 	includeProjectTree?: boolean;
 	userContext?: string;
-}): Promise<string> {
+}): Promise<ComposedSystemPrompt> {
+	const components: string[] = [];
 	if (options.spoofPrompt) {
-		return options.spoofPrompt.trim();
+		const prompt = options.spoofPrompt.trim();
+		const providerComponent = options.provider
+			? `spoof:${options.provider}`
+			: 'spoof:unknown';
+		return {
+			prompt,
+			components: [providerComponent],
+		};
 	}
 
 	const parts: string[] = [];
@@ -41,6 +55,18 @@ export async function composeSystemPrompt(options: {
 		baseInstructions.trim(),
 		options.agentPrompt.trim(),
 	);
+	if (providerPrompt.trim()) {
+		const providerComponent = options.provider
+			? `provider:${options.provider}`
+			: 'provider:unknown';
+		components.push(providerComponent);
+	}
+	if (baseInstructions.trim()) {
+		components.push('base');
+	}
+	if (options.agentPrompt.trim()) {
+		components.push('agent');
+	}
 
 	if (options.oneShot) {
 		const oneShotBlock =
@@ -51,6 +77,7 @@ export async function composeSystemPrompt(options: {
 				'</system-reminder>',
 			].join('\n');
 		parts.push(oneShotBlock);
+		components.push('mode:oneshot');
 	}
 
 	if (options.includeEnvironment !== false) {
@@ -60,6 +87,10 @@ export async function composeSystemPrompt(options: {
 		);
 		if (envAndInstructions) {
 			parts.push(envAndInstructions);
+			components.push('environment');
+			if (options.includeProjectTree) {
+				components.push('project-tree');
+			}
 		}
 	}
 
@@ -71,6 +102,7 @@ export async function composeSystemPrompt(options: {
 			'</user-provided-state-context>',
 		].join('\n');
 		parts.push(userContextBlock);
+		components.push('user-context');
 	}
 
 	// Add terminal context if available
@@ -79,17 +111,27 @@ export async function composeSystemPrompt(options: {
 		const terminalContext = terminalManager.getContext();
 		if (terminalContext) {
 			parts.push(terminalContext);
+			components.push('terminal-context');
 		}
 	}
 
 	const composed = parts.filter(Boolean).join('\n\n').trim();
-	if (composed) return composed;
+	if (composed) {
+		return {
+			prompt: composed,
+			components: dedupeComponents(components),
+		};
+	}
 
-	return [
+	const fallback = [
 		'You are a concise, friendly coding agent.',
 		'Be precise and actionable. Use tools when needed, prefer small diffs.',
 		'Stream your answer; call finish when done.',
 	].join(' ');
+	return {
+		prompt: fallback,
+		components: dedupeComponents([...components, 'fallback']),
+	};
 }
 
 export function getProviderSpoofPrompt(provider: string): string | undefined {
@@ -98,3 +140,15 @@ export function getProviderSpoofPrompt(provider: string): string | undefined {
 	}
 	return undefined;
 }
+
+function dedupeComponents(input: string[]): string[] {
+	const seen = new Set<string>();
+	const out: string[] = [];
+	for (const item of input) {
+		if (!item) continue;
+		if (seen.has(item)) continue;
+		seen.add(item);
+		out.push(item);
+	}
+	return out;
+}

package/src/runtime/runner.ts

@@ -61,6 +61,12 @@ export async function runSessionLoop(sessionId: string) {
  * Main function to run the assistant for a given request.
  */
 async function runAssistant(opts: RunOpts) {
+	const separator = '='.repeat(72);
+	debugLog(separator);
+	debugLog(
+		`[RUNNER] Starting turn for session ${opts.sessionId}, message ${opts.assistantMessageId}`,
+	);
+
 	const cfgTimer = time('runner:loadConfig+db');
 	const cfg = await loadConfig(opts.projectRoot);
 	const db = await getDb(cfg.projectRoot);
@@ -99,14 +105,19 @@ async function runAssistant(opts: RunOpts) {
 		: undefined;
 
 	debugLog(`[RUNNER] needsSpoof (OAuth): ${needsSpoof}`);
-	debugLog(`[RUNNER] spoofPrompt: ${spoofPrompt || 'NONE'}`);
+	debugLog(
+		`[RUNNER] spoofPrompt: ${spoofPrompt ? `present (${opts.provider})` : 'none'}`,
+	);
 
 	let system: string;
+	let systemComponents: string[] = [];
+	let oauthFullPromptComponents: string[] | undefined;
 	let additionalSystemMessages: Array<{ role: 'system'; content: string }> = [];
 
 	if (spoofPrompt) {
 		// OAuth mode: short spoof in system field, full instructions in messages array
 		system = spoofPrompt;
+		systemComponents = [`spoof:${opts.provider || 'unknown'}`];
 		const fullPrompt = await composeSystemPrompt({
 			provider: opts.provider,
 			model: opts.model,
@@ -117,26 +128,27 @@ async function runAssistant(opts: RunOpts) {
 			includeProjectTree: isFirstMessage,
 			userContext: opts.userContext,
 		});
+		oauthFullPromptComponents = fullPrompt.components;
 
 		// FIX: Always add the system message for OAuth because:
 		// 1. System messages are NOT stored in the database
 		// 2. buildHistoryMessages only returns user/assistant messages
 		// 3. We need the full instructions on every turn
-		additionalSystemMessages = [{ role: 'system', content: fullPrompt }];
+		additionalSystemMessages = [{ role: 'system', content: fullPrompt.prompt }];
 
 		debugLog('[RUNNER] OAuth mode: additionalSystemMessages created');
-		debugLog(`[RUNNER] fullPrompt length: ${fullPrompt.length}`);
+		const includesUserContext =
+			!!opts.userContext && fullPrompt.prompt.includes(opts.userContext);
 		debugLog(
-			`[RUNNER] fullPrompt contains userContext: ${fullPrompt.includes('<user-provided-state-context>') ? 'YES' : 'NO'}`,
+			`[system] oauth-full summary: ${JSON.stringify({
+				components: oauthFullPromptComponents ?? [],
+				length: fullPrompt.prompt.length,
+				includesUserContext,
+			})}`,
 		);
-		if (opts.userContext && fullPrompt.includes(opts.userContext)) {
-			debugLog('[RUNNER] ✅ userContext IS in fullPrompt');
-		} else if (opts.userContext) {
-			debugLog('[RUNNER] ❌ userContext NOT in fullPrompt!');
-		}
 	} else {
 		// API key mode: full instructions in system field
-		system = await composeSystemPrompt({
+		const composed = await composeSystemPrompt({
 			provider: opts.provider,
 			model: opts.model,
 			projectRoot: cfg.projectRoot,
@@ -146,10 +158,16 @@ async function runAssistant(opts: RunOpts) {
 			includeProjectTree: isFirstMessage,
 			userContext: opts.userContext,
 		});
+		system = composed.prompt;
+		systemComponents = composed.components;
 	}
 	systemTimer.end();
-	debugLog('[system] composed prompt (provider+base+agent):');
-	debugLog(system);
+	debugLog(
+		`[system] summary: ${JSON.stringify({
+			components: systemComponents,
+			length: system.length,
+		})}`,
+	);
 
 	const toolsTimer = time('runner:discoverTools');
 	const allTools = await discoverProjectTools(cfg.projectRoot);
@@ -500,5 +518,10 @@ async function runAssistant(opts: RunOpts) {
 			await completeAssistantMessage({}, opts, db);
 		} catch {}
 		throw err;
+	} finally {
+		debugLog(
+			`[RUNNER] Turn complete for session ${opts.sessionId}, message ${opts.assistantMessageId}`,
+		);
+		debugLog(separator);
 	}
 }

package/src/runtime/tool-context.ts

@@ -6,6 +6,7 @@ import { publish } from '../events/bus.ts';
 export type StepExecutionState = {
 	chain: Promise<void>;
 	failed: boolean;
+	failedToolName?: string;
 };
 
 export type ToolAdapterContext = {

package/src/tools/adapter.ts

@@ -10,6 +10,13 @@ import type {
 } from '../runtime/tool-context.ts';
 import { isToolError } from '@agi-cli/sdk/tools/error';
 
+function isSkippedToolCallError(error: unknown): boolean {
+	if (!isToolError(error)) return false;
+	const details = (error as { details?: unknown }).details;
+	if (!details || typeof details !== 'object') return false;
+	return 'skippedTool' in (details as Record<string, unknown>);
+}
+
 export type { ToolAdapterContext } from '../runtime/tool-context.ts';
 
 type ToolExecuteSignature = Tool['execute'] extends (
@@ -50,6 +57,10 @@ export function adaptTools(
 ) {
 	const out: Record<string, Tool> = {};
 	const pendingCalls = new Map<string, PendingCallMeta[]>();
+	const failureState: { active: boolean; toolName?: string } = {
+		active: false,
+		toolName: undefined,
+	};
 	let firstToolCallReported = false;
 
 	if (!ctx.stepExecution) {
@@ -289,19 +300,32 @@ export function adaptTools(
 						: 0;
 				let stepState = stepStates.get(stepKey);
 				if (!stepState) {
-					stepState = { chain: Promise.resolve(), failed: false };
+					stepState = {
+						chain: Promise.resolve(),
+						failed: false,
+						failedToolName: undefined,
+					};
 					stepStates.set(stepKey, stepState);
 				}
 
 				const executeWithGuards = async (): Promise<ToolExecuteReturn> => {
 					try {
-						if (stepState.failed) {
-							const skipError = {
-								ok: false,
-								error: `Cannot execute "${name}" because a previous tool call in this step failed. Retry the failing tool before continuing with "${name}".`,
-								details: { skippedTool: name },
-							};
-							throw skipError;
+						if (failureState.active) {
+							const expectedTool = failureState.toolName;
+							if (!expectedTool || expectedTool !== name) {
+								const skipError = {
+									ok: false,
+									error: expectedTool
+										? `Cannot execute "${name}" because "${expectedTool}" failed earlier in this step. Retry "${expectedTool}" before using other tools.`
+										: `Cannot execute "${name}" because a previous tool call in this session failed. Retry that tool before continuing with "${name}".`,
+									details: {
+										skippedTool: name,
+										reason: 'previous_tool_failed',
+										expectedTool,
+									},
+								};
+								throw skipError;
+							}
 						}
 						// Handle session-relative paths and cwd tools
 						let res: ToolExecuteReturn | { cwd: string } | null | undefined;
@@ -415,6 +439,12 @@ export function adaptTools(
 
 						// Special-case: keep progress_update result lightweight; publish first, persist best-effort
 						if (name === 'progress_update') {
+							stepState.failed = false;
+							stepState.failedToolName = undefined;
+							if (failureState.active && failureState.toolName === name) {
+								failureState.active = false;
+								failureState.toolName = undefined;
+							}
 							publish({
 								type: 'tool.result',
 								sessionId: ctx.sessionId,
@@ -444,6 +474,13 @@ export function adaptTools(
 							return result as ToolExecuteReturn;
 						}
 
+						stepState.failed = false;
+						stepState.failedToolName = undefined;
+						if (failureState.active && failureState.toolName === name) {
+							failureState.active = false;
+							failureState.toolName = undefined;
+						}
+
 						await ctx.db.insert(messageParts).values({
 							id: resultPartId,
 							messageId: ctx.messageId,
@@ -510,7 +547,14 @@ export function adaptTools(
 						}
 						return result as ToolExecuteReturn;
 					} catch (error) {
+						if (isSkippedToolCallError(error)) {
+							throw error;
+						}
+
 						stepState.failed = true;
+						stepState.failedToolName = name;
+						failureState.active = true;
+						failureState.toolName = name;
 
 						// Tool execution failed
 						if (