@xopcai/xopc 0.0.243 → 0.0.245

package/dist/src/agent/embedded/run-turn.js

@@ -1,20 +1,22 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { EmbeddedRunConflictError, abortEmbeddedRun, acquireEmbeddedRunLease, queueEmbeddedSteer } from "./runs.js";
+import { lastAssistantPlainText, subscribeEmbeddedSessionEvents } from "./subscribe-session.js";
+import { isContextOverflowError } from "../orchestration/context-overflow.js";
+import { getAssistantTurnErrorMessage, isAssistantTurnAborted, isAssistantTurnFailed, maybeRetryTurnAfterTransientLlmFailure, stripTrailingErrorAssistantMessages } from "../orchestration/llm-turn-retry.js";
 import { isAgentTurnUnsettledError, resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout } from "../orchestration/run-agent-turn-with-timeout.js";
+import { detectToolLoops } from "../orchestration/loop-guard.js";
+import { tryApplySessionTranscriptHygiene } from "../transcript/transcript-hygiene.js";
 import { resolvePromptCachePolicy } from "../../providers/prompt-cache-plan.js";
 import { wrapStreamFnForXopcExtensions } from "./xopc-stream-bridge.js";
 import { acquireEmbeddedSessionRunner, evictEmbeddedSessionRunner } from "./session-runner.js";
-import { markTurnToolResult } from "../memory/turn-provenance.js";
-import { isContextOverflowError } from "../orchestration/context-overflow.js";
-import { getAssistantTurnErrorMessage, isAssistantTurnAborted, isAssistantTurnFailed, maybeRetryTurnAfterTransientLlmFailure, stripTrailingErrorAssistantMessages } from "../orchestration/llm-turn-retry.js";
 import { projectContextForModel } from "../memory/context-budget.js";
-import { EmbeddedRunConflictError, abortEmbeddedRun, acquireEmbeddedRunLease, queueEmbeddedSteer } from "./runs.js";
-import { lastAssistantPlainText, subscribeEmbeddedSessionEvents } from "./subscribe-session.js";
-import { detectToolLoops } from "../orchestration/loop-guard.js";
-import { tryApplySessionTranscriptHygiene } from "../transcript/transcript-hygiene.js";
 import { createSqliteTranscriptRuntime } from "./transcript-runtime.js";
 import { buildPromptCacheSnapshot, observePromptCacheSnapshot } from "../../providers/prompt-cache-observability.js";
 import { isPromptCacheExpired, recordPromptCacheTouch } from "../../providers/prompt-cache-lifecycle.js";
+import { markTurnToolResult } from "../memory/turn-provenance.js";
+import { RepositoryInstructions } from "../coding/repository-instructions.js";
+import { RunVerification } from "../coding/run-verification.js";
 //#region src/agent/embedded/run-turn.ts
 init_logger();
 const log = createLogger("EmbeddedRun");
@@ -30,12 +32,17 @@ function extractTextFromContent(content) {
 	}).map((block) => block.text).join("");
 }
 function extractRecentToolCalls(messages) {
+	const lastUser = messages.findLastIndex((message) => message.role === "user");
+	messages = messages.slice(Math.max(0, lastUser));
 	const resultByToolCallId = /* @__PURE__ */ new Map();
+	const revisionByToolCallId = /* @__PURE__ */ new Map();
 	for (const message of messages) {
 		if (message.role !== "toolResult") continue;
 		const toolCallId = message.toolCallId;
 		if (typeof toolCallId !== "string" || !toolCallId) continue;
-		resultByToolCallId.set(toolCallId, truncateForLog(extractTextFromContent(message.content)));
+		resultByToolCallId.set(toolCallId, extractTextFromContent(message.content));
+		const revision = message.details?.workspaceRevision;
+		if (typeof revision === "string") revisionByToolCallId.set(toolCallId, revision);
 	}
 	const calls = [];
 	for (const message of messages) {
@@ -45,11 +52,12 @@ function extractRecentToolCalls(messages) {
 			calls.push({
 				name: toolCall.name,
 				params: toolCall.arguments,
+				...toolCall.id && revisionByToolCallId.has(toolCall.id) ? { revision: revisionByToolCallId.get(toolCall.id) } : {},
 				...toolCall.id && resultByToolCallId.has(toolCall.id) ? { resultPreview: resultByToolCallId.get(toolCall.id) } : {}
 			});
 		}
 	}
-	return calls;
+	return calls.slice(-12);
 }
 function getLastUserMessagePreview(messages) {
 	for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex--) {
@@ -119,6 +127,8 @@ async function runXopcEmbeddedTurn(params) {
 			sessionId: transcriptRuntime.sessionId,
 			runId
 		});
+		const instructions = await RepositoryInstructions.open(workspaceDir);
+		const rootInstructions = await instructions.load(".", true);
 		runner = await acquireEmbeddedSessionRunner({
 			runtimeId: transcriptRuntime.runtimeId,
 			sessionId: transcriptRuntime.sessionId,
@@ -126,7 +136,7 @@ async function runXopcEmbeddedTurn(params) {
 			model: resolvedModel,
 			modelRef: params.modelRef,
 			tools,
-			systemPrompt,
+			systemPrompt: [systemPrompt, rootInstructions].filter(Boolean).join("\n\n"),
 			thinkingLevel: thinkingLevel ?? "medium",
 			transcriptRuntime
 		});
@@ -143,6 +153,7 @@ async function runXopcEmbeddedTurn(params) {
 		runner.piSm.setActiveTurnId?.(runId);
 		const streamFnWithXopcExtensions = wrapStreamFnForXopcExtensions(session.agent.streamFunction, params.promptCachePolicy);
 		const loggingStreamFn = (streamModel, context, options) => {
+			instructions.acknowledge();
 			const sourceMessages = [...context.messages];
 			const hygienicMessages = tryApplySessionTranscriptHygiene(sourceMessages, streamModel);
 			const loopGuard = detectToolLoops(extractRecentToolCalls(hygienicMessages));
@@ -150,19 +161,14 @@ async function runXopcEmbeddedTurn(params) {
 				...context,
 				messages: hygienicMessages
 			};
-			if (loopGuard.injection || loopGuard.hiddenTools.size > 0) {
-				const messages = loopGuard.injection ? [...hygienicMessages, {
+			if (loopGuard.injection) effectiveContext = {
+				...effectiveContext,
+				messages: [...hygienicMessages, {
 					role: "user",
 					content: loopGuard.injection,
 					timestamp: Date.now()
-				}] : hygienicMessages;
-				const contextTools = loopGuard.hiddenTools.size > 0 && context.tools ? context.tools.filter((t) => !loopGuard.hiddenTools.has(t.name)) : context.tools;
-				effectiveContext = {
-					...context,
-					messages,
-					tools: contextTools
-				};
-			}
+				}]
+			};
 			const projection = projectContextForModel({
 				messages: effectiveContext.messages,
 				contextWindow: streamModel.contextWindow ?? 128e3,
@@ -203,7 +209,6 @@ async function runXopcEmbeddedTurn(params) {
 				toolCount: effectiveContext.tools?.length ?? 0,
 				lastUserMessagePreview: getLastUserMessagePreview(effectiveContext.messages),
 				loopWarningInjected: !!loopGuard.injection,
-				hiddenToolCount: loopGuard.hiddenTools.size,
 				promptCache: promptCacheSnapshot,
 				promptCacheChanges,
 				...process.env.XOPC_LOG_LLM_PAYLOAD === "true" ? { effectiveContext: {
@@ -215,10 +220,53 @@ async function runXopcEmbeddedTurn(params) {
 			return streamFnWithXopcExtensions(streamModel, effectiveContext, { ...options });
 		};
 		session.agent.streamFunction = loggingStreamFn;
+		const verification = await RunVerification.open(workspaceDir);
+		const checkpoints = runner.piSm.getBranch?.() ?? [];
+		const lastStart = checkpoints.findLastIndex((entry) => entry.type === "custom" && entry.customType === "coding_run_started");
+		const lastSummary = checkpoints.findLastIndex((entry) => entry.type === "custom" && entry.customType === "coding_verification");
+		const checkpoint = checkpoints[params.resumeLastUserMessage && lastSummary >= lastStart ? lastSummary : lastStart];
+		if (checkpoint?.type === "custom" && (params.resumeLastUserMessage || lastStart > lastSummary)) verification.restore(checkpoint.data, params.resumeLastUserMessage === true && lastSummary >= lastStart);
+		runner.piSm.appendCustomEntry("coding_run_started", {
+			runId,
+			workspace: workspaceDir,
+			required: params.verifyChanges ?? sessionKey.startsWith("agent:coder:"),
+			...await verification.summary()
+		});
+		let policyStopped = false;
 		params.turnPolicy?.reset();
-		session.agent.beforeToolCall = params.turnPolicy?.beforeToolCall;
-		session.agent.afterToolCall = params.turnPolicy?.afterToolCall;
-		session.agent.shouldStopAfterTurn = params.turnPolicy?.shouldStopAfterTurn;
+		session.agent.beforeToolCall = async (context, signal) => {
+			const decision = await params.turnPolicy?.beforeToolCall(context, signal);
+			if (decision?.block) {
+				policyStopped ||= decision.terminate === true;
+				return decision;
+			}
+			if (context.toolCall.name !== "read_file") {
+				const scoped = await instructions.forTool(context.toolCall.name, context.args);
+				if (scoped) return {
+					block: true,
+					reason: `${scoped}\n\nApply these instructions, then retry the operation.`
+				};
+			}
+			await verification.beforeTool(context.toolCall.id, context.toolCall.name);
+			return decision;
+		};
+		session.agent.afterToolCall = async (context) => {
+			const scoped = context.toolCall.name === "read_file" ? await instructions.forTool(context.toolCall.name, context.args) : "";
+			const checked = await verification.afterTool(context);
+			if (scoped) checked.result.content.unshift({
+				type: "text",
+				text: scoped
+			});
+			await params.turnPolicy?.afterToolCall({
+				...context,
+				...checked
+			});
+			return checked;
+		};
+		session.agent.shouldStopAfterTurn = (context) => {
+			policyStopped ||= params.turnPolicy?.shouldStopAfterTurn(context) ?? false;
+			return policyStopped;
+		};
 		unsubscribe = subscribeEmbeddedSessionEvents(session, (event) => {
 			if (event.type === "message_end" && event.message.role === "assistant") recordPromptCacheTouch(sessionKey, resolvedModel, event.message.usage);
 			if (event.type === "tool_execution_end") markTurnToolResult(sessionKey, runId, event.toolName);
@@ -226,7 +274,7 @@ async function runXopcEmbeddedTurn(params) {
 				...event,
 				runId
 			});
-		});
+		}, params.onAgentEvent);
 		const abortListener = () => {
 			session.abort();
 		};
@@ -253,7 +301,22 @@ async function runXopcEmbeddedTurn(params) {
 					abortSignal: runAbortSignal,
 					onEvent
 				});
+				const pending = await verification.pendingContext();
+				if ((params.verifyChanges ?? sessionKey.startsWith("agent:coder:")) && pending && !policyStopped && !runAbortSignal.aborted && !isAssistantTurnFailed(session.agent) && !isAssistantTurnAborted(session.agent)) {
+					await session.sendCustomMessage({
+						customType: "coding_verification",
+						content: pending,
+						display: false
+					}, { triggerTurn: true });
+					await session.agent.waitForIdle();
+				}
 			}, timeoutMs);
+			runner.piSm.appendCustomEntry("coding_verification", {
+				runId,
+				workspace: workspaceDir,
+				required: params.verifyChanges ?? sessionKey.startsWith("agent:coder:"),
+				...await verification.summary()
+			});
 			if (runAbortSignal.aborted) return {
 				ok: false,
 				errorMessage: "aborted"

package/dist/src/agent/embedded/session-tool-result-guard.js

@@ -1,10 +1,10 @@
 import { init_string_coerce, normalizeOptionalString } from "../../utils/string-coerce.js";
+import { extractToolCallsFromAssistant, extractToolResultId } from "../transcript/tool-call-id.js";
+import { makeMissingToolResult, sanitizeToolCallInputs } from "../transcript/session-transcript-repair.js";
 import { boundedJsonUtf8Bytes, firstEnumerableOwnKeys, jsonUtf8BytesOrInfinity } from "../../infra/json-utf8-bytes.js";
 import { emitSessionTranscriptUpdate } from "../../session/transcript-events.js";
 import { formatContextLimitTruncationNotice } from "./tool-result-context-guard.js";
 import { resolveLiveToolResultMaxChars, truncateToolResultMessage } from "./tool-result-truncation.js";
-import { extractToolCallsFromAssistant, extractToolResultId } from "../transcript/tool-call-id.js";
-import { makeMissingToolResult, sanitizeToolCallInputs } from "../transcript/session-transcript-repair.js";
 //#region src/agent/embedded/session-tool-result-guard.ts
 init_string_coerce();
 /**

package/dist/src/agent/embedded/subscribe-session.d.ts

@@ -1,4 +1,5 @@
 import type { AgentSession } from '@earendil-works/pi-coding-agent';
+import type { AgentEvent } from '@earendil-works/pi-agent-core';
 import type { EmbeddedStreamEvent } from './types.js';
-export declare function subscribeEmbeddedSessionEvents(session: AgentSession, onEvent: (event: EmbeddedStreamEvent) => void): () => void;
+export declare function subscribeEmbeddedSessionEvents(session: AgentSession, onEvent: (event: EmbeddedStreamEvent) => void, onAgentEvent?: (event: AgentEvent) => void): () => void;
 export declare function lastAssistantPlainText(session: AgentSession): string | undefined;

package/dist/src/agent/embedded/subscribe-session.js

@@ -1,8 +1,9 @@
 import { extractTextContent } from "../context/workspace.js";
 //#region src/agent/embedded/subscribe-session.ts
-function subscribeEmbeddedSessionEvents(session, onEvent) {
+function subscribeEmbeddedSessionEvents(session, onEvent, onAgentEvent) {
 	return session.subscribe((event) => {
 		const base = event;
+		onAgentEvent?.(base);
 		switch (base.type) {
 			case "agent_start":
 				onEvent({ type: "agent_start" });

package/dist/src/agent/embedded/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentMessage, AgentToolResult, ThinkingLevel } from '@earendil-works/pi-agent-core';
+import type { AgentEvent, AgentMessage, AgentToolResult, ThinkingLevel } from '@earendil-works/pi-agent-core';
 import type { AssistantMessageEvent, Model, Api, ImageContent } from '@earendil-works/pi-ai';
 import type { TurnOutcome } from '@xopcai/gateway-contract';
 import type { SessionStore } from '../../session/store.js';
@@ -106,9 +106,11 @@ export type RunXopcEmbeddedTurnParams = {
     turnPolicy?: AgentTurnPolicy;
     abortSignal?: AbortSignal;
     onEvent?: (event: EmbeddedStreamEvent) => void;
+    onAgentEvent?: (event: AgentEvent) => void;
     images?: ImageContent[];
     /** Continue from the persisted trailing user row instead of appending it again. */
     resumeLastUserMessage?: boolean;
+    verifyChanges?: boolean;
 };
 export type RunXopcEmbeddedTurnResult = {
     ok: boolean;

package/dist/src/agent/embedded/xopc-tools-bridge.js

@@ -84,7 +84,10 @@ function invalidApplyPatchEnvelopeResult(error) {
 			type: "text",
 			text: `apply_patch input rejected (${error.issue}). Expected: ${error.expected}.${received} ${error.retryHint} Use this exact envelope:\n${APPLY_PATCH_BEGIN_MARKER}\n*** Update File: path\n@@\n-old\n+new\n${APPLY_PATCH_END_MARKER}`
 		}],
-		details: error
+		details: {
+			...error,
+			status: "failed"
+		}
 	};
 }
 /** Map xopc {@link AgentTool} instances to pi-coding-agent {@link ToolDefinition}s for `createAgentSession`. */

package/dist/src/agent/image/index.js

@@ -1,9 +1,9 @@
 import { getImageUnderstandingProvider, listImageUnderstandingProviders, registerImageUnderstandingProvider } from "./understanding/provider-registry.js";
 import { resolveImageModelConfigForTool } from "./tool-model-config.js";
 import { describeImages, describeImagesWithFallback } from "./understanding/runtime.js";
+import { modelSupportsVision, resolveImageHandlingStrategy } from "./vision-detection.js";
 import { runWithImageModelFallback } from "./image-model-fallback.js";
 import { loadImageForToolInput } from "./load-image-media.js";
 import { getImageGenerationProvider, listImageGenerationProviders } from "./generation/provider-registry.js";
 import { generateImage, listImageGenerationProvidersSummary } from "./generation/runtime.js";
-import { modelSupportsVision, resolveImageHandlingStrategy } from "./vision-detection.js";
 export { describeImages, describeImagesWithFallback, generateImage, getImageGenerationProvider, getImageUnderstandingProvider, listImageGenerationProviders, listImageGenerationProvidersSummary, listImageUnderstandingProviders, loadImageForToolInput, modelSupportsVision, registerImageUnderstandingProvider, resolveImageHandlingStrategy, resolveImageModelConfigForTool, runWithImageModelFallback };

package/dist/src/agent/index.js

@@ -1,13 +1,13 @@
+import { resolveTranscriptPolicy } from "./transcript/transcript-policy.js";
+import { dropThinkingBlocks } from "./transcript/thinking.js";
 import { extractToolCallsFromAssistant, extractToolResultId, sanitizeToolCallId, sanitizeToolCallIdsForCloudCodeAssist } from "./transcript/tool-call-id.js";
 import { makeMissingToolResult, repairToolUseResultPairing, sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolResultDetails } from "./transcript/session-transcript-repair.js";
+import { applySessionTranscriptHygiene, applySessionTranscriptHygieneForPersistence, applySessionTranscriptHygieneWithPolicy, resolvePolicyForModel, tryApplySessionTranscriptHygiene, tryApplySessionTranscriptHygieneForPersistence } from "./transcript/transcript-hygiene.js";
 import { createResponseMessage, createSignalMessage, createTaskMessage, isValidIPCMessage } from "./ipc/types.js";
 import { AgentInbox } from "./ipc/inbox.js";
 import { AgentBus } from "./ipc/bus.js";
 import { AgentSocketClient, AgentSocketServer, isSocketAvailable } from "./ipc/socket.js";
 import "./ipc/index.js";
-import { resolveTranscriptPolicy } from "./transcript/transcript-policy.js";
-import { dropThinkingBlocks } from "./transcript/thinking.js";
-import { applySessionTranscriptHygiene, applySessionTranscriptHygieneForPersistence, applySessionTranscriptHygieneWithPolicy, resolvePolicyForModel, tryApplySessionTranscriptHygiene, tryApplySessionTranscriptHygieneForPersistence } from "./transcript/transcript-hygiene.js";
 import { AgentService } from "./service.js";
 import { stripToolMessages } from "./transcript/strip-tool-messages.js";
 import "./transcript/index.js";

package/dist/src/agent/memory/user-context-coordinator.js

@@ -1,9 +1,9 @@
 import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
+import { consumeTurnMemoryProvenance, markTurnRecalledContext } from "./turn-provenance.js";
 import { assembleTaskContext } from "../../tasks/task-context-assembler.js";
 import { shouldPlanUserContextThisTurn } from "./memory-config.js";
 import { UserContextPlanner, prependAgentContext } from "../../user-context/planner.js";
 import { extractAgentUserPlainText } from "./user-message-text.js";
-import { consumeTurnMemoryProvenance, markTurnRecalledContext } from "./turn-provenance.js";
 import { planTrustedRecall } from "./trusted-recall.js";
 //#region src/agent/memory/user-context-coordinator.ts
 init_session_key();

package/dist/src/agent/middleware/index.d.ts

@@ -1,6 +1 @@
-/**
- * Agent middleware — request-scoped log context (`ContextMiddleware`) and
- * harness-style self-verify tracking (`SelfVerifyMiddleware`).
- */
-export { SelfVerifyMiddleware, type FileEditRecord, type SelfVerifyConfig, type SelfVerifyAgentKind, type SelfVerifyState, type VerificationTask, type VerificationRecord, } from './self-verify.js';
 export { ContextMiddleware, type RequestContext } from './context.js';

package/dist/src/agent/middleware/index.js

@@ -1,3 +1,2 @@
-import { SelfVerifyMiddleware } from "./self-verify.js";
 import { ContextMiddleware } from "./context.js";
-export { ContextMiddleware, SelfVerifyMiddleware };
+export { ContextMiddleware };

package/dist/src/agent/orchestration/agent-event-handler.d.ts

@@ -18,11 +18,9 @@ import type { ToolErrorTracker } from '../tools/error-tracker.js';
 import type { RequestLimiter } from '../models/request-limiter.js';
 import type { LifecycleManager } from '../lifecycle/index.js';
 import type { ToolChainTracker } from '../tools/chain-tracker.js';
-import type { SelfVerifyMiddleware } from '../middleware/index.js';
 import type { SystemReminder } from '../prompt/system-reminder.js';
 import type { ToolUsageAnalyzer } from '../tools/usage-analyzer.js';
 import type { ErrorPatternMatcher } from '../tools/error-pattern-matcher.js';
-import type { TurnDiffTracker } from '../coding/index.js';
 export type SessionEventListener = (event: AgentEvent, context: SessionContext) => void;
 export type SessionEventTypeFilter = AgentEvent['type'] | 'all';
 /**
@@ -35,17 +33,14 @@ export declare class SessionEventBus {
     on(type: SessionEventTypeFilter, listener: SessionEventListener): () => void;
     dispatch(event: AgentEvent, context: SessionContext | null): void;
 }
-export declare function readChangedPathsFromToolEnd(toolName: string, args: unknown, result: unknown): string[];
 export interface AgentEventHandlerConfig {
     errorTracker: ToolErrorTracker;
     requestLimiter: RequestLimiter;
     lifecycleManager: LifecycleManager;
     toolChainTracker: ToolChainTracker;
-    selfVerifyMiddleware: SelfVerifyMiddleware;
     systemReminder: SystemReminder;
     toolUsageAnalyzer: ToolUsageAnalyzer;
     errorPatternMatcher: ErrorPatternMatcher;
-    turnDiffTracker?: TurnDiffTracker;
 }
 /**
  * Thin façade over {@link SessionEventBus} that pre-registers all built-in

package/dist/src/agent/orchestration/agent-event-handler.js

@@ -122,58 +122,6 @@ function installSystemReminderListener(bus, systemReminder) {
 		e.result = systemReminder.appendToResult(e.result, e.toolName);
 	});
 }
-function appendTextToToolResult(result, text) {
-	if (!text.trim()) return result;
-	if (result && typeof result === "object") {
-		const res = result;
-		if (Array.isArray(res.content)) {
-			res.content = [...res.content, {
-				type: "text",
-				text: `\n${text}`
-			}];
-			return res;
-		}
-		if (typeof res.content === "string") {
-			res.content = `${res.content}\n${text}`;
-			return res;
-		}
-	}
-	return result;
-}
-function readRecord(value) {
-	return value && typeof value === "object" ? value : null;
-}
-function readToolResultDetails(result) {
-	const rec = readRecord(result);
-	if (!rec) return null;
-	return readRecord(rec.details);
-}
-function readStringArray(value) {
-	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-function readChangedPathsFromToolEnd(toolName, args, result) {
-	const name = toolName.toLowerCase();
-	const details = readToolResultDetails(result);
-	if (name === "apply_patch") {
-		const files = readStringArray(details?.files);
-		if (files.length > 0) return files;
-		return (Array.isArray(details?.changes) ? details.changes : []).flatMap((change) => {
-			const rec = readRecord(change);
-			if (!rec) return [];
-			return readStringArray([rec.moveTo, rec.path]);
-		});
-	}
-	if (name === "write_file") {
-		if (typeof details?.size !== "number") return [];
-		const rec = readRecord(args);
-		return typeof rec?.path === "string" ? [rec.path] : [];
-	}
-	if (name.includes("write") || name.includes("edit")) {
-		const rec = readRecord(args);
-		return typeof rec?.path === "string" ? [rec.path] : [];
-	}
-	return [];
-}
 function installToolChainListener(bus, toolChainTracker) {
 	bus.on("turn_start", (_event, context) => {
 		toolChainTracker.startChain(context.sessionKey);
@@ -231,47 +179,6 @@ function installErrorTrackingListener(bus, deps) {
 		deps.errorTracker.reset();
 	});
 }
-function installSelfVerifyListener(bus, selfVerifyMiddleware) {
-	bus.on("tool_execution_end", (event, context) => {
-		const e = event;
-		const name = e.toolName?.toLowerCase() ?? "";
-		const args = e.args;
-		if (name === "exec_command") {
-			selfVerifyMiddleware.recordVerification(e.toolName, args, {
-				isError: e.isError,
-				result: e.result
-			}, context.sessionKey);
-			return;
-		}
-		if (!e.isError) {
-			const changedPaths = readChangedPathsFromToolEnd(e.toolName, args, e.result);
-			for (const path of changedPaths) selfVerifyMiddleware.recordEdit(path, name.includes("write") ? "write" : "edit", context.sessionKey);
-			if (changedPaths.length > 0) {
-				e.result = appendTextToToolResult(e.result, selfVerifyMiddleware.consumePostEditReminder(context.sessionKey));
-				return;
-			}
-			selfVerifyMiddleware.recordVerification(e.toolName, args, {
-				isError: e.isError,
-				result: e.result
-			}, context.sessionKey);
-		}
-	});
-	bus.on("turn_start", (_event, context) => {
-		selfVerifyMiddleware.onTurnStart(context.sessionKey);
-	});
-}
-function installTurnDiffTrackerListener(bus, turnDiffTracker) {
-	bus.on("tool_execution_end", (event, context) => {
-		const e = event;
-		turnDiffTracker.recordToolResult({
-			sessionKey: context.sessionKey,
-			toolName: e.toolName,
-			args: e.args,
-			result: e.result,
-			isError: e.isError
-		});
-	});
-}
 /**
 * Thin façade over {@link SessionEventBus} that pre-registers all built-in
 * listeners in their required order. `handle(event, ctx)` is the entry point
@@ -288,8 +195,6 @@ var AgentEventHandler = class {
 		});
 		installLifecycleHookListener(this.bus, config.lifecycleManager);
 		installSystemReminderListener(this.bus, config.systemReminder);
-		if (config.turnDiffTracker) installTurnDiffTrackerListener(this.bus, config.turnDiffTracker);
-		installSelfVerifyListener(this.bus, config.selfVerifyMiddleware);
 		installToolUsageListener(this.bus, config.toolUsageAnalyzer);
 		installToolChainListener(this.bus, config.toolChainTracker);
 		installErrorTrackingListener(this.bus, {
@@ -312,4 +217,4 @@ var AgentEventHandler = class {
 	}
 };
 //#endregion
-export { AgentEventHandler, SessionEventBus, readChangedPathsFromToolEnd };
+export { AgentEventHandler, SessionEventBus };

package/dist/src/agent/orchestration/agent-orchestrator.js

@@ -1,11 +1,11 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { runContextConsolidation } from "../../user-context/consolidation.js";
+import { abortEmbeddedRun } from "../embedded/runs.js";
 import { persistInboundAttachments } from "../../channels/attachments/inbound-persist.js";
 import { buildTranscriptUserMessage, clearPendingTranscriptUserMessage, hydrateUserTurnForLlm, setPendingTranscriptUserMessage } from "../inbound/attachment-pipeline.js";
 import { extractAgentUserPlainText } from "../memory/user-message-text.js";
 import { resolveEffectiveThinkingLevel } from "../../session/thinking-resolve.js";
-import { abortEmbeddedRun } from "../embedded/runs.js";
 import { runEmbeddedTurnForSession } from "../embedded/run-for-session.js";
 import { randomUUID } from "node:crypto";
 //#region src/agent/orchestration/agent-orchestrator.ts

package/dist/src/agent/orchestration/agent-turn-policy.js

@@ -1,15 +1,14 @@
 //#region src/agent/orchestration/agent-turn-policy.ts
-function assistantMessageCount(messages) {
-	return messages.filter((message) => message.role === "assistant").length;
-}
 /** One user-visible run policy. A fresh instance is created for every embedded run. */
 function createAgentTurnPolicy(options) {
 	const toolCalls = /* @__PURE__ */ new Map();
 	let toolFailures = 0;
+	let assistantTurns = 0;
 	return {
 		reset() {
 			toolCalls.clear();
 			toolFailures = 0;
+			assistantTurns = 0;
 		},
 		async beforeToolCall(context, signal) {
 			const limit = options.resolveToolLimit?.(context.toolCall.name, context.args);
@@ -27,8 +26,9 @@ function createAgentTurnPolicy(options) {
 		async afterToolCall(context) {
 			if (context.isError) toolFailures += 1;
 		},
-		shouldStopAfterTurn(context) {
-			return Boolean(options.maxTurns && assistantMessageCount(context.newMessages) >= options.maxTurns || options.maxToolFailures && toolFailures >= options.maxToolFailures);
+		shouldStopAfterTurn(_context) {
+			assistantTurns += 1;
+			return Boolean(options.maxTurns && assistantTurns >= options.maxTurns || options.maxToolFailures && toolFailures >= options.maxToolFailures);
 		}
 	};
 }

package/dist/src/agent/orchestration/index.d.ts

@@ -2,4 +2,4 @@
  * Orchestration Layer - Exports all orchestration-related modules
  */
 export { AgentOrchestrator, type AgentOrchestratorConfig } from './agent-orchestrator.js';
-export { AgentEventHandler, SessionEventBus, readChangedPathsFromToolEnd, type AgentEventHandlerConfig, type SessionEventListener, type SessionEventTypeFilter, } from './agent-event-handler.js';
+export { AgentEventHandler, SessionEventBus, type AgentEventHandlerConfig, type SessionEventListener, type SessionEventTypeFilter, } from './agent-event-handler.js';

package/dist/src/agent/orchestration/index.js

@@ -1,3 +1,3 @@
 import { AgentOrchestrator } from "./agent-orchestrator.js";
-import { AgentEventHandler, SessionEventBus, readChangedPathsFromToolEnd } from "./agent-event-handler.js";
-export { AgentEventHandler, AgentOrchestrator, SessionEventBus, readChangedPathsFromToolEnd };
+import { AgentEventHandler, SessionEventBus } from "./agent-event-handler.js";
+export { AgentEventHandler, AgentOrchestrator, SessionEventBus };

package/dist/src/agent/orchestration/loop-guard.d.ts

@@ -1,37 +1,10 @@
-/**
- * Loop Guard — Detects repetitive tool call patterns within an agent turn
- * and produces context injections for the LLM.
- *
- * Design: pure function that analyzes recent tool call history (already in
- * the transcript) and returns:
- * - A developer-role message to inject into the next LLM request
- * - A set of tool names to temporarily hide from the model
- *
- * This operates at the orchestration layer (before LLM sees tools/messages)
- * rather than the execution layer, so the model naturally stops calling
- * blocked tools without receiving confusing "fake" tool outputs.
- */
 export interface RecentToolCall {
     name: string;
     params: unknown;
-    /** Optional: tool result text (for same-result detection). */
     resultPreview?: string;
+    revision?: string;
 }
-export interface LoopGuardConfig {
-    /** Consecutive identical calls before injecting a soft warning (default: 2). */
-    softThreshold: number;
-    /** Consecutive identical calls before hiding the tool (default: 3). */
-    hideThreshold: number;
-}
-export interface LoopGuardResult {
-    /** Developer message to inject into LLM context (null = no loop). */
+/** Warn on a stalled tail, without removing tools needed to recover or verify a repair. */
+export declare function detectToolLoops(recentCalls: readonly RecentToolCall[]): {
     injection: string | null;
-    /** Tool names to remove from the available tools list. */
-    hiddenTools: Set<string>;
-}
-/**
- * Analyze recent tool calls and produce loop guard result.
- *
- * Pure function — no side effects, no shared state.
- */
-export declare function detectToolLoops(recentCalls: readonly RecentToolCall[], config?: Partial<LoopGuardConfig>): LoopGuardResult;
+};