opencode-agent-skill 15.0.0 → 15.1.1

package/pi/extensions/ues.ts

@@ -33,17 +33,23 @@ import { findReusableVerification, listReusableVerification, recordVerification
 import { evaluateFastVerificationGate } from "../../lib/fast-verification-gate.mjs";
 import { turboFastPathDecision, turboFastTimeoutBudget } from "../../lib/turbo-fast-path.mjs";
 import { failureDelta, leafTaskPolicy } from "../../lib/leaf-runtime-optimizer.mjs";
+import { classifyProviderFailure, providerRecoveryBackoffMs } from "../../lib/provider-recovery.mjs";
 import { planningRuntimeBudget, shouldSoftSteerArchitect, shouldSoftSteerPlanningRole } from "../../lib/planning-speed-policy.mjs";
 import { sourceFacingPaths, sourceGitPathspecs } from "../../lib/runtime-artifacts.mjs";
+import { createSubagentArtifact, failSubagentArtifact, finalizeSubagentArtifact, listSubagentArtifacts, readSubagentArtifact } from "../../lib/subagent-artifacts.mjs";
 import { buildExecutionContract, buildFinalVerdictMatrix, captureInheritedDirtyState, detectInheritedDirtyViolations, enforcePhaseGates, executionContractPrompt, phaseArtifactPayloads, taskExplicitlyAllowsLocalEnvWrite } from "../../lib/execution-contract.mjs";
+import { buildCompactionResumeGuard, checkpointDurableWorkBeforeCompaction, renderCompactionResumeGuard } from "../../lib/compaction-resume-guard.mjs";
 import { sessionNameFromUesInput, uesSessionName } from "../../lib/session-display.mjs";
 import { requireGitWorkspaceRoot, resolveGitWorkspaceRoot } from "../../lib/workspace-root.mjs";
 import { createAdaptiveDeadline } from "../../lib/activity-deadline.mjs";
 import { extractValidatedPlan } from "../../lib/plan-salvage.mjs";
 import { auditCompletion } from "../../lib/completion-auditor.mjs";
 import { mcpExecutionPolicy } from "../../lib/mcp-tool-policy.mjs";
+import { PermissionPolicyStore, permissionRecoveryHint, toolPermissionRequest } from "../../lib/permission-policy.mjs";
+import { analyzeUntrustedOutput, renderUntrustedOutputWarning } from "../../lib/untrusted-output.mjs";
 import { McpHealthTracker } from "../../lib/mcp-health.mjs";
-import { runtimeWorkspaceFingerprint, runtimeWorkspaceSnapshot } from "../../lib/workspace-fingerprint.mjs";
+import { captureWorkspaceStateV2, runtimeWorkspaceFingerprint, runtimeWorkspaceSnapshot } from "../../lib/workspace-fingerprint.mjs";
+import { captureWorkspaceHygieneBaseline, postRunFileHygiene, preFinalWorkspaceAudit } from "../../lib/workspace-hygiene.mjs";
 import { appendTrajectoryEvent, createTraceID } from "../../lib/trajectory.mjs";
 import {
   browserEvidenceNeeded,
@@ -53,6 +59,17 @@ import {
 } from "../../lib/browser-mcp-routing.mjs";
 import { clearRepoGraphRuntimeCache } from "../../lib/repo-graph.mjs";
 import { clearSemanticIndexRuntimeCache } from "../../lib/semantic-index.mjs";
+import {
+  diagnoseCode,
+  lspOperation,
+  lspPoolStatus,
+  probeCodeIntelligence,
+  readAnchoredCode,
+  searchCodeIntelligence,
+  shutdownLspPool,
+} from "../../lib/code-intelligence/index.mjs";
+import { ingestDocument } from "../../lib/document-ingestion.mjs";
+import { compactContext, expandContext, searchContext } from "../../lib/reversible-context.mjs";
 import {
   createTaskSandbox,
   integrateTaskSandbox,
@@ -158,6 +175,22 @@ const CONTEXT_CACHE_MAX = configuredCount(
   4,
   128,
 );
+const PROVIDER_RECOVERY_RETRIES = (() => {
+  const parsed = Number(process.env.UES_PROVIDER_RECOVERY_RETRIES ?? "1");
+  if (!Number.isFinite(parsed)) return 1;
+  return Math.max(0, Math.min(2, Math.trunc(parsed)));
+})();
+const PROVIDER_SESSION_RESUME_RETRIES = (() => {
+  const parsed = Number(process.env.UES_PROVIDER_SESSION_RESUME_RETRIES ?? "1");
+  if (!Number.isFinite(parsed)) return 1;
+  return Math.max(0, Math.min(2, Math.trunc(parsed)));
+})();
+const PROVIDER_RECOVERY_BASE_DELAY_MS = configuredDuration(
+  "UES_PROVIDER_RECOVERY_BASE_DELAY_MS",
+  250,
+  50,
+  5_000,
+);
 
 function configuredBoolean(name: string, fallback = true) {
   const raw = String(process.env[name] ?? "").trim().toLowerCase();
@@ -183,6 +216,9 @@ const MCP_HEALTH = new McpHealthTracker({
   failureThreshold: 2,
   cooldownMs: configuredDuration("UES_MCP_HEALTH_COOLDOWN_MS", 15_000, 1_000, 5 * 60_000),
 });
+const PERMISSION_POLICY = new PermissionPolicyStore(
+  path.join(getUesConfigDir(), ".ues", "permissions.json"),
+);
 
 function abortActiveCliChildren() {
   let aborted = 0;
@@ -272,6 +308,10 @@ type RunResult = {
   browserTools?: string[];
   childRuntime?: "rpc" | "cli";
   workerReused?: boolean;
+  providerFailure?: string;
+  providerRecoveryAttempts?: number;
+  providerSessionResumeAttempts?: number;
+  subagentArtifact?: any;
   optimizations?: any;
 };
 
@@ -659,6 +699,7 @@ async function runAgentCli(
     idleTimeoutMs?: number;
     postToolErrorIdleTimeoutMs?: number;
     allowLocalEnvWrite?: boolean;
+    reuseRpcSession?: boolean;
   } = {},
 ): Promise<RunResult> {
   const config = AGENTS[agent];
@@ -719,6 +760,7 @@ async function runAgentCli(
           UES_CHILD_TOOL_OUTPUT_LIMIT: String(runtimeOptions.toolOutputLimit || 24 * 1024),
           UES_CHILD_VERIFICATION_TIMEOUT_SEC: String(runtimeOptions.verificationTimeoutSec || 300),
           UES_CHILD_ALLOW_LOCAL_ENV_WRITE: runtimeOptions.allowLocalEnvWrite ? "1" : "0",
+          UES_CHILD_EXTERNAL_TOOL_NAMES: extraTools.join(","),
         },
         shell: false,
         detached: process.platform !== "win32",
@@ -1007,11 +1049,17 @@ async function runAgentCli(
 }
 
 
+const RPC_PROMPT_PATH_CACHE = new Map<AgentName, string>();
+
 function rpcPromptPath(agent: AgentName) {
+  const cached = RPC_PROMPT_PATH_CACHE.get(agent);
+  if (cached && fs.existsSync(cached)) return cached;
+
   const dir = path.join(os.tmpdir(), "ues-pi-rpc-prompts");
   fs.mkdirSync(dir, { recursive: true });
   const file = path.join(dir, agent + ".md");
   fs.writeFileSync(file, getAgentPrompt(agent), { encoding: "utf8", mode: 0o600 });
+  RPC_PROMPT_PATH_CACHE.set(agent, file);
   return file;
 }
 
@@ -1044,6 +1092,7 @@ async function runAgentRpc(
     idleTimeoutMs?: number;
     postToolErrorIdleTimeoutMs?: number;
     allowLocalEnvWrite?: boolean;
+    reuseRpcSession?: boolean;
   } = {},
 ): Promise<RunResult> {
   const config = AGENTS[agent];
@@ -1124,6 +1173,7 @@ async function runAgentRpc(
           UES_CHILD_TOOL_OUTPUT_LIMIT: String(runtimeOptions.toolOutputLimit || 24 * 1024),
           UES_CHILD_VERIFICATION_TIMEOUT_SEC: String(runtimeOptions.verificationTimeoutSec || 300),
           UES_CHILD_ALLOW_LOCAL_ENV_WRITE: runtimeOptions.allowLocalEnvWrite ? "1" : "0",
+          UES_CHILD_EXTERNAL_TOOL_NAMES: extraTools.join(","),
         },
       },
       taskInput,
@@ -1135,6 +1185,7 @@ async function runAgentRpc(
         activityWindowMs,
         idleTimeoutMs,
         postToolErrorIdleTimeoutMs,
+        reuseSession: runtimeOptions.reuseRpcSession === true,
         onEvent: (event: any) => {
           lastActivityAt = Date.now();
           if (event.type === "tool_execution_start") {
@@ -1182,13 +1233,13 @@ async function runAgentRpc(
     );
 
     const message = rpc.message;
-    const output = extractAssistantText(message) || rpc.stderr || "(no assistant output)";
-    return {
+    const assistantText = extractAssistantText(message);
+    const baseResult: RunResult = {
       agent,
       task,
       cwd,
-      exitCode: 0,
-      output: cap(output, 100 * 1024),
+      exitCode: message?.stopReason === "error" ? 1 : 0,
+      output: cap(assistantText || rpc.stderr || "(no assistant output)", 100 * 1024),
       stderr: cap(String(rpc.stderr || ""), 64 * 1024),
       model: message?.model || model,
       stopReason: message?.stopReason,
@@ -1200,6 +1251,16 @@ async function runAgentRpc(
       childRuntime: "rpc",
       workerReused: rpc.workerReused === true,
     };
+    const providerDecision = classifyProviderFailure(baseResult);
+    if (providerDecision.transient) {
+      return {
+        ...baseResult,
+        exitCode: 1,
+        providerFailure: providerDecision.reason || "empty-provider-response",
+        errorMessage: baseResult.errorMessage || providerDecision.message || "Provider returned no usable assistant content",
+      };
+    }
+    return baseResult;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (detectedHang) {
@@ -1284,54 +1345,137 @@ async function runAgent(
     idleTimeoutMs?: number;
     postToolErrorIdleTimeoutMs?: number;
     allowLocalEnvWrite?: boolean;
+    reuseRpcSession?: boolean;
   } = {},
 ): Promise<RunResult> {
-  if (CHILD_RUNTIME !== "cli") {
+  const runOnce = async (): Promise<RunResult> => {
+    if (CHILD_RUNTIME !== "cli") {
+      try {
+        return await runAgentRpc(
+          agent, task, cwd, model, thinkingLevel, signal, onProgress, extraTools, runtimeOptions,
+        );
+      } catch (error) {
+        if (CHILD_RUNTIME === "rpc") throw error;
+        // Auto mode may fall back only when RPC failed before delegated work started.
+        if ((error as any)?.uesRpcPhase && (error as any).uesRpcPhase !== "startup") throw error;
+        try {
+          onProgress?.({
+            agent, elapsedMs: 0, idleMs: 0, toolCalls: 0, model, phase: "running",
+            note: "RPC startup unavailable; falling back to isolated CLI child",
+          });
+        } catch {}
+      }
+    }
+    return runAgentCli(
+      agent, task, cwd, model, thinkingLevel, signal, onProgress, extraTools, runtimeOptions,
+    );
+  };
+
+  let result = await runOnce();
+  let recoveryAttempts = 0;
+  let sessionResumeAttempts = 0;
+  let providerDecision = classifyProviderFailure(result);
+
+  while (
+    providerDecision.transient && providerDecision.safeSessionResume &&
+    result.childRuntime === "rpc" &&
+    sessionResumeAttempts < PROVIDER_SESSION_RESUME_RETRIES && !signal?.aborted
+  ) {
+    sessionResumeAttempts += 1;
     try {
-      return await runAgentRpc(
+      onProgress?.({
+        agent, elapsedMs: 0, idleMs: 0, toolCalls: Number(result.toolCalls || 0),
+        model: result.model || model, phase: "running",
+        note: "provider returned no usable content after tool execution; resuming the same RPC session " +
+          sessionResumeAttempts + "/" + PROVIDER_SESSION_RESUME_RETRIES,
+      });
+    } catch {}
+    const delayMs = providerRecoveryBackoffMs(sessionResumeAttempts, {
+      baseMs: PROVIDER_RECOVERY_BASE_DELAY_MS, maxMs: 2_000,
+    });
+    if (delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+
+    const priorToolCalls = Number(result.toolCalls || 0);
+    const priorToolNames = Array.isArray(result.toolNames) ? result.toolNames : [];
+    try {
+      const resumed = await runAgentRpc(
         agent,
-        task,
+        [
+          "Continue the current delegated task from this existing RPC session after a transient provider failure.",
+          "Do not restart the task and do not repeat tool calls that already completed.",
+          "Use the current conversation, workspace state, and tool evidence as authoritative.",
+          "Continue from the next unfinished step, then return the normal role report/verdict.",
+        ].join(" "),
         cwd,
-        model,
+        result.model || model,
         thinkingLevel,
         signal,
         onProgress,
         extraTools,
-        runtimeOptions,
+        { ...runtimeOptions, reuseRpcSession: true },
       );
+      result = {
+        ...resumed,
+        task,
+        toolCalls: priorToolCalls + Number(resumed.toolCalls || 0),
+        toolNames: [...new Set([...priorToolNames, ...(resumed.toolNames || [])])],
+      };
+      providerDecision = classifyProviderFailure(result);
     } catch (error) {
-      if (CHILD_RUNTIME === "rpc") throw error;
-      // Auto mode may fall back only when RPC failed before the delegated task
-      // started. In-task failures must not cause a blind second execution.
-      if ((error as any)?.uesRpcPhase && (error as any).uesRpcPhase !== "startup") {
-        throw error;
-      }
       try {
         onProgress?.({
-          agent,
-          elapsedMs: 0,
-          idleMs: 0,
-          toolCalls: 0,
-          model,
-          phase: "running",
-          note: "RPC startup unavailable; falling back to isolated CLI child",
+          agent, elapsedMs: 0, idleMs: 0, toolCalls: priorToolCalls,
+          model: result.model || model, phase: "running",
+          note: "same-session provider recovery unavailable; preserving prior evidence without replay",
         });
       } catch {}
+      break;
     }
   }
-  return runAgentCli(
-    agent,
-    task,
-    cwd,
-    model,
-    thinkingLevel,
-    signal,
-    onProgress,
-    extraTools,
-    runtimeOptions,
-  );
-}
 
+  while (
+    providerDecision.transient && providerDecision.safeReplay &&
+    recoveryAttempts < PROVIDER_RECOVERY_RETRIES && !signal?.aborted
+  ) {
+    recoveryAttempts += 1;
+    try {
+      onProgress?.({
+        agent, elapsedMs: 0, idleMs: 0, toolCalls: Number(result.toolCalls || 0),
+        model: result.model || model, phase: "running",
+        note: "provider returned no usable content; safe fresh-session retry " +
+          recoveryAttempts + "/" + PROVIDER_RECOVERY_RETRIES,
+      });
+    } catch {}
+    const delayMs = providerRecoveryBackoffMs(recoveryAttempts, {
+      baseMs: PROVIDER_RECOVERY_BASE_DELAY_MS, maxMs: 2_000,
+    });
+    if (delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+    result = await runOnce();
+    providerDecision = classifyProviderFailure(result);
+  }
+
+  if (providerDecision.transient) {
+    const recoveryNote = providerDecision.safeReplay
+      ? "UES provider recovery exhausted after " + recoveryAttempts +
+        " bounded fresh-session retry attempt(s); task remains failed instead of being reported as success."
+      : providerDecision.safeSessionResume
+        ? "UES same-session provider recovery exhausted or was unavailable after " + sessionResumeAttempts +
+          " attempt(s). Completed tool side effects were preserved and were not blindly replayed."
+        : "UES provider recovery stopped safely without replaying completed side effects.";
+    result = {
+      ...result,
+      exitCode: result.exitCode === 0 ? 1 : result.exitCode,
+      output: [result.output, "", "[UES provider recovery] " + recoveryNote].filter(Boolean).join("\n"),
+      providerFailure: providerDecision.reason || result.providerFailure || "empty-provider-response",
+    };
+  }
+
+  return {
+    ...result,
+    providerRecoveryAttempts: recoveryAttempts,
+    providerSessionResumeAttempts: sessionResumeAttempts,
+  };
+}
 
 function roleForAgent(agent: AgentName) {
   return agent.replace(/^ues-/, "");
@@ -1382,6 +1526,11 @@ function parseStructuredReport(output: string) {
   };
 }
 
+function acceptanceEvidenceStatusPresent(run: any) {
+  const value = String(run?.report?.sections?.["acceptance-criteria-proven"] || "");
+  return /(?:^|\n)\s*(?:[-*]\s*)?(?:VERIFIED|INFERRED|UNKNOWN)\s*:/im.test(value);
+}
+
 function taskRecord(task: string) {
   return {
     id: "pi-dispatch",
@@ -1510,8 +1659,24 @@ async function runRoutedAgent(
   taskPolicyOverride?: any,
   contextCacheNamespace?: string,
 ): Promise<RunResult> {
+  const routedStartedAt = Date.now();
   const role = roleForAgent(agent);
   const traceRoot = requireGitWorkspaceRoot(cwd, "UES specialist");
+  const workspaceSnapshotStartedAt = Date.now();
+  let agentWorkspaceState: any = null;
+  let workspaceState: any = {
+    cacheable: false,
+    fingerprint: "unknown",
+    changedFiles: [],
+  };
+  try {
+    agentWorkspaceState = captureWorkspaceStateV2(cwd);
+    workspaceState = runtimeWorkspaceSnapshot(cwd, { workspaceState: agentWorkspaceState });
+  } catch {}
+  const agentHygieneBaseline = captureWorkspaceHygieneBaseline(cwd, {
+    workspaceState: agentWorkspaceState,
+  });
+  const workspaceSnapshotMs = Date.now() - workspaceSnapshotStartedAt;
   const browserRequested = browserEvidenceNeeded(task, role);
   const browserTools = browserRequested
     ? selectBrowserToolsForTask(HOST_BROWSER_TOOL_NAMES, task, role)
@@ -1545,6 +1710,8 @@ async function runRoutedAgent(
       modelTier: selection.tier,
       profile: taskPolicy.executionProfile,
       risk: taskPolicy.risk,
+      decisionConfidence: taskPolicy.decision?.confidence ?? null,
+      decisionReason: taskPolicy.decision?.reason ?? null,
       browserRequested,
     }).catch(() => {});
   }
@@ -1573,14 +1740,6 @@ async function runRoutedAgent(
     ? undefined
     : inheritedThinking;
 
-  let workspaceState: any = {
-    cacheable: false,
-    fingerprint: "unknown",
-    changedFiles: [],
-  };
-  try {
-    workspaceState = runtimeWorkspaceSnapshot(cwd);
-  } catch {}
   const workspaceFingerprint = String(workspaceState.fingerprint || "unknown");
 
   let enrichedTask = task;
@@ -1590,6 +1749,8 @@ async function runRoutedAgent(
   let affectedTests: any = null;
   let reusableVerification: any = null;
   let contextCacheHit = false;
+  let contextPerformance: any = null;
+  const contextBuildStartedAt = Date.now();
   try {
     if (fastBoundedContext) {
       contextQuality = { schemaVersion: 1, profile: "fast-bounded", bounded: true };
@@ -1650,41 +1811,42 @@ async function runRoutedAgent(
       }
     }
 
-    if (MICRO_SKILLS_ENABLED) {
-      microSkills = await compileSkillContext(taskPolicy, role, {
-        maxSkills: taskPolicy.maxSkills,
-        totalChars: taskPolicy.executionProfile === "fast" ? 1800 : 3200,
-      }).catch(() => null);
-    }
-
-    if (
+    const [microSkillResult, affectedTestResult, reusableVerificationResult] = await Promise.all([
+      MICRO_SKILLS_ENABLED
+        ? compileSkillContext(taskPolicy, role, {
+            maxSkills: taskPolicy.maxSkills,
+            totalChars: taskPolicy.executionProfile === "fast" ? 1800 : 3200,
+            taskText: task,
+          }).catch(() => null)
+        : Promise.resolve(null),
       AFFECTED_TEST_HINTS_ENABLED &&
       ["executor", "debugger", "verifier", "integration-verifier"].includes(role)
-    ) {
-      affectedTests = await resolveAffectedTests(cwd, {
-        limit: 10,
-        changedFiles: workspaceState.changedFiles || [],
-        ...(workspaceState.cacheable === true && workspaceFingerprint !== "unknown"
-          ? { workspaceFingerprint }
-          : {}),
-      }).catch(() => null);
-    }
-
-    if (
+        ? resolveAffectedTests(cwd, {
+            limit: 10,
+            changedFiles: workspaceState.changedFiles || [],
+            ...(workspaceState.cacheable === true && workspaceFingerprint !== "unknown"
+              ? { workspaceFingerprint }
+              : {}),
+          }).catch(() => null)
+        : Promise.resolve(null),
       ["verifier", "integration-verifier"].includes(role) &&
       !["high", "critical"].includes(String(taskPolicy.risk || "").toLowerCase())
-    ) {
-      reusableVerification = await listReusableVerification(cwd, {
-        limit: 8,
-        maxAgeMs: 30 * 60_000,
-        previewBytes: 2200,
-        ...(workspaceState.cacheable === true && workspaceFingerprint !== "unknown"
-          ? { workspaceFingerprint }
-          : {}),
-      }).catch(() => null);
-    }
+        ? listReusableVerification(cwd, {
+            limit: 8,
+            maxAgeMs: 30 * 60_000,
+            previewBytes: 2200,
+            ...(workspaceState.cacheable === true && workspaceFingerprint !== "unknown"
+              ? { workspaceFingerprint }
+              : {}),
+          }).catch(() => null)
+        : Promise.resolve(null),
+    ]);
+    microSkills = microSkillResult;
+    affectedTests = affectedTestResult;
+    reusableVerification = reusableVerificationResult;
 
     contextQuality = pack.contextQuality;
+    contextPerformance = pack.performance || null;
     enrichedTask = [
       task,
       "",
@@ -1723,6 +1885,7 @@ async function runRoutedAgent(
       enrichedTask += "\n\n## Previous failed verification\n" + cap(recentFailure, 5000);
     }
   }
+  const contextBuildMs = Date.now() - contextBuildStartedAt;
 
   if (browserRequested) {
     enrichedTask += browserTools.length
@@ -1747,7 +1910,34 @@ async function runRoutedAgent(
     taskChars: task.length,
   });
   const startedAt = Date.now();
-  const result = await runAgent(
+  const artifactRoot = await taskSandboxOwnerRoot(cwd).catch(() => null) || traceRoot;
+  const childArtifact = await createSubagentArtifact(artifactRoot, {
+    agent,
+    role,
+    attempt,
+    task,
+    traceID,
+    model: selectedModel,
+    modelTier: selection.tier,
+    workspaceFingerprint,
+  }).catch(() => null);
+  if (childArtifact?.handle) {
+    try {
+      onProgress?.({
+        agent,
+        elapsedMs: 0,
+        idleMs: 0,
+        toolCalls: 0,
+        model: selectedModel,
+        phase: "running",
+        note: `subagent handle ${childArtifact.handle}; durable status ${childArtifact.file}`,
+      });
+    } catch {}
+  }
+  let result: RunResult;
+  const modelRunStartedAt = Date.now();
+  try {
+    result = await runAgent(
     agent,
     enrichedTask,
     cwd,
@@ -1801,8 +1991,56 @@ async function runRoutedAgent(
       allowLocalEnvWrite:
         taskPolicy.localEnvWriteExplicitlyAllowed === true ||
         taskExplicitlyAllowsLocalEnvWrite(task),
-    },
-  );
+      },
+    );
+  } catch (error) {
+    if (childArtifact?.handle) {
+      await failSubagentArtifact(artifactRoot, childArtifact.handle, error).catch(() => null);
+    }
+    throw error;
+  }
+  const modelRunMs = Date.now() - modelRunStartedAt;
+  const hygieneStartedAt = Date.now();
+  const postRunHygiene = await postRunFileHygiene(cwd, {
+    baseline: agentHygieneBaseline,
+    taskText: task,
+    allowSourceMutations: WRITE_AGENTS.has(agent),
+    autoClean: true,
+  }).catch((error) => ({
+    schemaVersion: 1,
+    safe: false,
+    changed: [],
+    created: [],
+    removed: [],
+    findings: [{
+      kind: "hygiene-audit-error",
+      file: ".",
+      message: error instanceof Error ? error.message : String(error),
+    }],
+    summary: "workspace hygiene audit failed: " + (error instanceof Error ? error.message : String(error)),
+  }));
+  if (!postRunHygiene.safe) {
+    const hygieneText = [
+      "UES post-run workspace hygiene guard rejected this child run.",
+      postRunHygiene.summary || "workspace hygiene failed",
+    ].join("\n");
+    result = {
+      ...result,
+      exitCode: result.exitCode === 0 ? 2 : result.exitCode,
+      stopReason: "error",
+      errorMessage: hygieneText,
+      output: [result.output, "", hygieneText].filter(Boolean).join("\n"),
+    };
+  }
+
+  const hygieneMs = Date.now() - hygieneStartedAt;
+    const finalizedChildArtifact = childArtifact?.handle
+    ? await finalizeSubagentArtifact(artifactRoot, childArtifact.handle, {
+        ...result,
+        durationMs: Date.now() - startedAt,
+        verdict: verdictFromOutput(result.output),
+      }).catch(() => null)
+    : null;
   const enrichedResult: RunResult = {
     ...result,
     task,
@@ -1833,10 +2071,32 @@ async function runRoutedAgent(
       turboFastStrategy: turboFast.strategy,
       turboFastTimeouts: turboFast.eligible ? TURBO_FAST_TIMEOUTS : null,
       planningRuntimeBudget: planningBudget,
+      affectedTestInventorySource: affectedTests?.inventorySource || null,
+      contextPerformance,
+      latencyMs: {
+        workspaceSnapshot: workspaceSnapshotMs,
+        contextBuild: contextBuildMs,
+        modelRun: modelRunMs,
+        hygiene: hygieneMs,
+        total: Date.now() - routedStartedAt,
+      },
     },
     verdict: verdictFromOutput(result.output),
     report: parseStructuredReport(result.output),
     durationMs: Date.now() - startedAt,
+    subagentArtifact: finalizedChildArtifact ? {
+      handle: finalizedChildArtifact.handle,
+      status: finalizedChildArtifact.status,
+      file: finalizedChildArtifact.file,
+      taskRef: finalizedChildArtifact.taskRef,
+      outputRef: finalizedChildArtifact.result?.outputRef || null,
+      resume: finalizedChildArtifact.resume || null,
+    } : childArtifact ? {
+      handle: childArtifact.handle,
+      status: childArtifact.status,
+      file: childArtifact.file,
+      taskRef: childArtifact.taskRef,
+    } : null,
   };
   if (traceID) {
     await appendTrajectoryEvent(traceRoot, traceID, "agent.completed", {
@@ -2813,8 +3073,16 @@ export default function (pi: ExtensionAPI) {
   const AUTO_ADMISSION_ENABLED = !["0", "false", "off"].includes(
     String(process.env.UES_AUTO_ADMIT || "1").trim().toLowerCase(),
   );
-  const UES_PARENT_TOOL_NAMES = new Set(["ues_cli", "ues_execute", "ues_service", "ues_dispatch"]);
+  const UES_PARENT_TOOL_NAMES = new Set(["ues_cli", "ues_execute", "ues_service", "ues_session", "ues_dispatch"]);
+  const ALWAYS_ON_PARENT_TOOLS = new Set(["ues_code"]);
   let normalActiveTools: string[] | null = null;
+  let parentRunToolCalls = 0;
+  let parentRunLastAssistant: any = null;
+  let parentProviderRecoveryConsecutive = 0;
+  let parentProviderRecoveryTotal = 0;
+  let parentProviderRecoveryPending = false;
+  const PARENT_PROVIDER_RECOVERY_MAX_CONSECUTIVE = 1;
+  const PARENT_PROVIDER_RECOVERY_MAX_TOTAL = 3;
 
   const currentNonUesTools = () =>
     pi.getActiveTools().filter((name) => !UES_PARENT_TOOL_NAMES.has(String(name)));
@@ -2848,6 +3116,40 @@ export default function (pi: ExtensionAPI) {
     deactivateParentUesTools();
   });
 
+  pi.on("session_before_compact", async (event, ctx) => {
+    const root = resolveGitWorkspaceRoot(ctx.cwd || "");
+    if (!root) return undefined;
+    await checkpointDurableWorkBeforeCompaction(root, {
+      reason: event.reason,
+      maxWorkspaces: 3,
+    }).catch(() => []);
+    return undefined;
+  });
+
+  pi.on("session_compact", async (event, ctx) => {
+    const root = resolveGitWorkspaceRoot(ctx.cwd || "");
+    if (!root) return;
+    const packet = await buildCompactionResumeGuard(root, {
+      reason: event.reason,
+      maxWorkspaces: 3,
+    }).catch(() => null);
+    if (!packet?.workspaces?.length) return;
+    const content = renderCompactionResumeGuard(packet);
+    if (!content) return;
+    pi.sendMessage({
+      customType: "ues-durable-resume-guard",
+      content,
+      display: false,
+      details: {
+        schemaVersion: packet.schemaVersion || 1,
+        reason: event.reason,
+        willRetry: event.willRetry,
+        workspaceCount: packet.workspaceCount,
+        source: packet.source,
+      },
+    }, { triggerTurn: false });
+  });
+
   pi.on("session_shutdown", async () => {
     directControllerAbort?.abort();
     directControllerAbort = null;
@@ -2861,6 +3163,7 @@ export default function (pi: ExtensionAPI) {
     MCP_HEALTH.clear();
     abortActiveCliChildren();
     await stopAllServices().catch(() => []);
+    await shutdownLspPool().catch(() => ({ stopped: 0, remaining: 0 }));
     await RPC_POOL.stopAll().catch(() => {});
     for (const dir of [...ACTIVE_TASK_SANDBOXES.keys()]) {
       const ownerRoot = await taskSandboxOwnerRoot(dir).catch(() => null);
@@ -2966,13 +3269,27 @@ export default function (pi: ExtensionAPI) {
       return { action: "continue" };
     }
 
-    const steered = await RPC_POOL.steerActive(text).catch(() => ({
-      accepted: false,
-      reason: "steer-failed",
-      active: 0,
-    }));
-    if (steered.accepted) {
-      try { ctx.ui.notify("UES: steering message forwarded to the active child", "info"); } catch {}
+    const streamingBehavior = String(event.streamingBehavior || "");
+    const forwarded = streamingBehavior === "followUp"
+      ? await RPC_POOL.followUpActive(text).catch(() => ({
+          accepted: false,
+          reason: "follow-up-failed",
+          active: 0,
+        }))
+      : await RPC_POOL.steerActive(text).catch(() => ({
+          accepted: false,
+          reason: "steer-failed",
+          active: 0,
+        }));
+    if (forwarded.accepted) {
+      try {
+        ctx.ui.notify(
+          streamingBehavior === "followUp"
+            ? "UES: follow-up queued for the active child"
+            : "UES: steering message forwarded to the active child",
+          "info",
+        );
+      } catch {}
       return { action: "handled" };
     }
 
@@ -2982,19 +3299,109 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.on("before_agent_start", async () => {
+    // Pi may start another provider request inside the same parent run when
+    // agent_before_settle asks to continue. Preserve recovery accounting for
+    // that continuation, but reset it for a genuinely new parent run.
+    if (parentProviderRecoveryPending) {
+      parentProviderRecoveryPending = false;
+      parentRunLastAssistant = null;
+    } else {
+      parentRunToolCalls = 0;
+      parentRunLastAssistant = null;
+      parentProviderRecoveryConsecutive = 0;
+      parentProviderRecoveryTotal = 0;
+    }
     if (uesModeActive()) activateParentUesTools();
     else deactivateParentUesTools();
   });
 
+  pi.on("message_end", async (event) => {
+    if ((event as any)?.message?.role !== "assistant") return;
+    parentRunLastAssistant = (event as any).message;
+
+    // A substantive assistant response proves the previous empty-response
+    // incident recovered. Reset only the consecutive incident budget; keep the
+    // total run budget bounded so a flaky provider cannot loop forever.
+    const text = extractAssistantText(parentRunLastAssistant).trim();
+    if (text && parentRunLastAssistant?.stopReason !== "error") {
+      parentProviderRecoveryConsecutive = 0;
+      parentProviderRecoveryPending = false;
+    }
+  });
+
+  pi.on("agent_before_settle", async (event) => {
+    if (
+      uesModeActive() ||
+      parentProviderRecoveryConsecutive >= PARENT_PROVIDER_RECOVERY_MAX_CONSECUTIVE ||
+      parentProviderRecoveryTotal >= PARENT_PROVIDER_RECOVERY_MAX_TOTAL
+    ) {
+      return undefined;
+    }
+
+    const assistantText = extractAssistantText(parentRunLastAssistant);
+    const decision = classifyProviderFailure({
+      output: assistantText || "(no assistant output)",
+      errorMessage: parentRunLastAssistant?.errorMessage,
+      stopReason: parentRunLastAssistant?.stopReason,
+      toolCalls: parentRunToolCalls,
+      noAssistantMessage: !parentRunLastAssistant,
+    });
+    if (!decision.transient) return undefined;
+
+    parentProviderRecoveryConsecutive += 1;
+    parentProviderRecoveryTotal += 1;
+    parentProviderRecoveryPending = true;
+    const afterTools = parentRunToolCalls > 0;
+    const recoveryMessage = afterTools
+      ? [
+          "UES parent provider recovery: the previous provider response was empty after completed tool calls.",
+          "Continue from the current conversation and existing tool results.",
+          "Do not restart the task and do not repeat tool calls that already completed unless fresh verification is strictly required.",
+          "Resume from the next unfinished step and finish the requested work/report.",
+        ].join(" ")
+      : [
+          "UES parent provider recovery: the previous provider response was empty before any tool side effect.",
+          "Retry the current request once using the existing conversation context and return a complete response.",
+        ].join(" ");
+
+    return {
+      entries: [
+        ...(event.entries || []),
+        {
+          type: "custom_message",
+          customType: "ues-parent-provider-recovery",
+          content: recoveryMessage,
+          display: false,
+          details: {
+            schemaVersion: 2,
+            incidentAttempt: parentProviderRecoveryConsecutive,
+            maxIncidentAttempts: PARENT_PROVIDER_RECOVERY_MAX_CONSECUTIVE,
+            totalAttempts: parentProviderRecoveryTotal,
+            maxTotalAttempts: PARENT_PROVIDER_RECOVERY_MAX_TOTAL,
+            reason: decision.reason,
+            toolCalls: parentRunToolCalls,
+            safeReplay: decision.safeReplay,
+            safeSessionResume: decision.safeSessionResume,
+          },
+        },
+      ],
+      continue: true,
+    };
+  });
+
   pi.on("agent_end", async () => {
     promptUesActive = false;
+    parentProviderRecoveryPending = false;
+    parentProviderRecoveryConsecutive = 0;
+    parentProviderRecoveryTotal = 0;
     deactivateParentUesTools();
   });
 
   pi.on("tool_call", async (event, ctx) => {
     const toolName = String(event.toolName || "");
+    if (!uesModeActive()) parentRunToolCalls += 1;
     if (!uesModeActive()) {
-      if (toolName.startsWith("ues_")) {
+      if (toolName.startsWith("ues_") && !ALWAYS_ON_PARENT_TOOLS.has(toolName)) {
         return {
           block: true,
           reason: "UES parent tools are hidden outside admitted UES runs. Submit a normal engineering task or start an explicit /ues-* command.",
@@ -3002,11 +3409,48 @@ export default function (pi: ExtensionAPI) {
       }
       return undefined;
     }
+    const permissionRequest = toolPermissionRequest(toolName, (event as any).input || {});
+    const configuredPermission: any = await PERMISSION_POLICY.evaluate(permissionRequest, {
+      agent: "ues-parent",
+    }).catch((error) => ({
+      configured: true,
+      decision: null,
+      error: error instanceof Error ? error.message : String(error),
+    }));
+    if (configuredPermission.error) {
+      return {
+        block: true,
+        reason: "UES permission policy is invalid: " + configuredPermission.error,
+      };
+    }
+    const permissionEffect = configuredPermission?.decision?.effect;
+    let permissionApproved = false;
+    if (permissionEffect === "deny") {
+      return {
+        block: true,
+        reason: permissionRecoveryHint(permissionRequest, configuredPermission.decision, { effect: "deny" }),
+      };
+    }
+    if (permissionEffect === "ask") {
+      const allowed = await approveRisk(
+        ctx,
+        permissionRequest.resources.join("\n"),
+        "permission:" + permissionRequest.action,
+      );
+      if (!allowed) {
+        return {
+          block: true,
+          reason: permissionRecoveryHint(permissionRequest, configuredPermission.decision, { effect: "ask" }),
+        };
+      }
+      permissionApproved = true;
+    }
+
     if (toolName !== "bash" && toolName !== "powershell") {
       const allTools = typeof (pi as any).getAllTools === "function" ? (pi as any).getAllTools() : [];
       const descriptor = allTools.find((tool: any) => String(tool?.name || "") === toolName);
       const policy = mcpExecutionPolicy(descriptor || { name: toolName });
-      if (policy.confirmationRequired) {
+      if (policy.confirmationRequired && !permissionApproved) {
         const allowed = await approveRisk(ctx, `MCP/tool call: ${toolName}`, `mcp-destructive:${toolName}`);
         if (!allowed) return { block: true, reason: `Blocked by UES MCP destructive-hint gate: ${toolName}` };
       }
@@ -3025,8 +3469,10 @@ export default function (pi: ExtensionAPI) {
     }
     const risk = destructiveShellRisk(command);
     if (!risk.risky) return undefined;
-    const allowed = await approveRisk(ctx, command, risk.id || "destructive");
-    if (!allowed) return { block: true, reason: `Blocked by UES safety gate: ${risk.id}` };
+    if (!permissionApproved) {
+      const allowed = await approveRisk(ctx, command, risk.id || "destructive");
+      if (!allowed) return { block: true, reason: `Blocked by UES safety gate: ${risk.id}` };
+    }
     return undefined;
   });
 
@@ -3034,14 +3480,222 @@ export default function (pi: ExtensionAPI) {
     if (!uesModeActive()) return undefined;
     const toolName = String((event as any).toolName || "");
     if (!toolName || toolName === "bash" || toolName === "powershell") return undefined;
+    const resultText = toolResultText(event);
+    const allTools = typeof (pi as any).getAllTools === "function" ? (pi as any).getAllTools() : [];
+    const descriptor = allTools.find((tool: any) => String(tool?.name || "") === toolName);
+    const policy = mcpExecutionPolicy(descriptor || { name: toolName });
     MCP_HEALTH.finish(
       String((event as any).toolCallId || ""),
       {
         isError: (event as any).isError === true,
-        text: toolResultText(event),
+        text: resultText,
       },
     );
-    return undefined;
+
+    const externalBoundary =
+      policy.externalEvidenceBoundary === true ||
+      HOST_BROWSER_TOOL_NAMES.includes(toolName);
+    if (!externalBoundary || !resultText) return undefined;
+
+    const analysis = analyzeUntrustedOutput(resultText, { source: toolName });
+    if (!analysis.flagged) return undefined;
+    const originalContent = Array.isArray((event as any).content)
+      ? (event as any).content
+      : [{ type: "text", text: resultText }];
+    return {
+      content: [
+        { type: "text", text: renderUntrustedOutputWarning(analysis, { source: toolName }) },
+        ...originalContent,
+      ],
+      details: {
+        ...((event as any).details && typeof (event as any).details === "object" ? (event as any).details : {}),
+        uesUntrustedOutputBoundary: analysis,
+      },
+      isError: (event as any).isError === true,
+      usage: (event as any).usage,
+    };
+  });
+
+  // Always-on, read-only intelligence for normal Pi conversations.
+  // Keep this outside UES_PARENT_TOOL_NAMES so session_start does not hide it.
+  pi.registerTool({
+    name: "ues_code",
+    label: "UES Code Intelligence Lite",
+    description:
+      "Always-on read-only UES code intelligence for normal Pi chats. Provides bounded semantic/AST search, anchored reads, persistent LSP navigation/diagnostics, document ingestion, and reversible context access without starting the UES controller or a specialist child.",
+    parameters: Type.Object({
+      action: Type.Union([
+        Type.Literal("status"),
+        Type.Literal("search"),
+        Type.Literal("read"),
+        Type.Literal("diagnostics"),
+        Type.Literal("definition"),
+        Type.Literal("references"),
+        Type.Literal("symbols"),
+        Type.Literal("hover"),
+        Type.Literal("rename-preview"),
+        Type.Literal("incoming-calls"),
+        Type.Literal("outgoing-calls"),
+        Type.Literal("document"),
+        Type.Literal("context-expand"),
+        Type.Literal("context-search"),
+      ]),
+      file: Type.Optional(Type.String()),
+      query: Type.Optional(Type.String()),
+      structuralPattern: Type.Optional(Type.String()),
+      language: Type.Optional(Type.String()),
+      startLine: Type.Optional(Type.Number({ minimum: 1 })),
+      endLine: Type.Optional(Type.Number({ minimum: 1 })),
+      line: Type.Optional(Type.Number({ minimum: 1 })),
+      character: Type.Optional(Type.Number({ minimum: 1 })),
+      newName: Type.Optional(Type.String({ minLength: 1, maxLength: 512 })),
+      includeDeclaration: Type.Optional(Type.Boolean()),
+      ref: Type.Optional(Type.String()),
+      maxBytes: Type.Optional(Type.Number({ minimum: 1, maximum: 128000 })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        let result: any;
+        if (params.action === "status") {
+          result = probeCodeIntelligence(params.file || "");
+          result = {
+            ...result,
+            mode: "parent-lite",
+            controllerStarted: false,
+            childSpawned: false,
+            lsp: {
+              ...result.lsp,
+              persistentPool: {
+                ...lspPoolStatus({ includeSessions: false, persistent: true }),
+                policy: { enabled: true, source: "parent-lite" },
+              },
+            },
+          };
+        } else if (params.action === "search") {
+          if (!params.query) throw new Error("ues_code search requires query");
+          result = await searchCodeIntelligence(ctx.cwd, params.query, {
+            structuralPattern: params.structuralPattern,
+            language: params.language,
+            file: params.file,
+            maxResults: 12,
+          });
+          result.mode = "parent-lite";
+        } else if (params.action === "read") {
+          if (!params.file) throw new Error("ues_code read requires file");
+          const startLine = Math.max(1, Math.trunc(Number(params.startLine || 1)));
+          const endLine = Math.max(startLine, Math.min(startLine + 399, Math.trunc(Number(params.endLine || startLine + 199))));
+          const read = await readAnchoredCode(ctx.cwd, params.file, { startLine, endLine });
+          return {
+            content: [{ type: "text", text: [
+              `file: ${read.file}; lines: ${read.startLine}-${read.endLine}/${read.lineCount}; sourceHash: ${read.sourceHash}`,
+              "",
+              read.text,
+            ].join("\n") }],
+            details: {
+              action: params.action,
+              mode: "parent-lite",
+              controllerStarted: false,
+              childSpawned: false,
+              file: read.file,
+              sourceHash: read.sourceHash,
+              startLine: read.startLine,
+              endLine: read.endLine,
+            },
+          };
+        } else if (params.action === "diagnostics") {
+          if (!params.file) throw new Error("ues_code diagnostics requires file");
+          result = await diagnoseCode(ctx.cwd, params.file, {
+            timeoutMs: 5000,
+            maxResults: 80,
+            persistent: true,
+          });
+        } else if (["definition", "references", "symbols", "hover", "rename-preview", "incoming-calls", "outgoing-calls"].includes(params.action)) {
+          if (!params.file) throw new Error(`ues_code ${params.action} requires file`);
+          if (params.action === "rename-preview" && !params.newName) throw new Error("ues_code rename-preview requires newName");
+          result = await lspOperation(ctx.cwd, params.file, params.action, {
+            line: params.line || 1,
+            character: params.character || 1,
+            newName: params.newName,
+            includeDeclaration: params.includeDeclaration,
+            timeoutMs: 7000,
+            maxResults: 120,
+            persistent: true,
+          });
+        } else if (params.action === "document") {
+          if (!params.file) throw new Error("ues_code document requires file");
+          const document = await ingestDocument(ctx.cwd, params.file, {
+            maxBytes: Math.min(Number(params.maxBytes || 4 * 1024 * 1024), 4 * 1024 * 1024),
+          });
+          const block = await compactContext(ctx.cwd, document.markdown, {
+            kind: "document-ingestion",
+            source: document.file,
+            summary: `Normalized document from ${document.provider}`,
+          });
+          result = {
+            provider: document.provider,
+            file: document.file,
+            bytes: document.bytes,
+            optionalDependency: document.optionalDependency,
+            contextRef: block.ref,
+            originalChars: block.originalChars,
+            summary: block.levels.T1,
+          };
+        } else if (params.action === "context-expand") {
+          if (!params.ref) throw new Error("ues_code context-expand requires ref");
+          const expanded = await expandContext(ctx.cwd, params.ref, { maxBytes: params.maxBytes || 16000 });
+          return {
+            content: [{ type: "text", text: expanded.content }],
+            details: {
+              action: params.action,
+              mode: "parent-lite",
+              controllerStarted: false,
+              childSpawned: false,
+              ref: expanded.ref,
+              start: expanded.start,
+              returnedBytes: expanded.returnedBytes,
+              truncated: expanded.truncated,
+            },
+          };
+        } else if (params.action === "context-search") {
+          if (!params.ref || !params.query) throw new Error("ues_code context-search requires ref and query");
+          result = await searchContext(ctx.cwd, params.ref, params.query, {
+            maxBytes: params.maxBytes || 512000,
+            maxMatches: 12,
+          });
+        } else {
+          throw new Error("unsupported ues_code action");
+        }
+
+        const payload = {
+          ...result,
+          mode: result?.mode || "parent-lite",
+          controllerStarted: false,
+          childSpawned: false,
+        };
+        const encoded = JSON.stringify(payload, null, 2);
+        return {
+          content: [{ type: "text", text: encoded.length <= 32000 ? encoded : encoded.slice(0, 32000) + "\n...[bounded by ues_code parent-lite]" }],
+          details: {
+            action: params.action,
+            mode: "parent-lite",
+            controllerStarted: false,
+            childSpawned: false,
+            bounded: encoded.length > 32000,
+          },
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          details: {
+            action: params.action,
+            mode: "parent-lite",
+            controllerStarted: false,
+            childSpawned: false,
+          },
+          isError: true,
+        };
+      }
+    },
   });
 
   pi.registerTool({
@@ -3197,6 +3851,60 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
+  pi.registerTool({
+    name: "ues_session",
+    label: "UES Session Control",
+    description:
+      "Control the single active Pi RPC specialist session without shell orchestration. Supports state inspection, steer vs follow-up queueing, abort, queue clearing, model/thinking changes, compaction, and bounded wait. Fails closed when zero or multiple child sessions are active.",
+    parameters: Type.Object({
+      action: Type.Union([
+        Type.Literal("status"),
+        Type.Literal("get-state"),
+        Type.Literal("steer"),
+        Type.Literal("follow-up"),
+        Type.Literal("abort"),
+        Type.Literal("clear-queue"),
+        Type.Literal("set-model"),
+        Type.Literal("set-thinking"),
+        Type.Literal("compact"),
+        Type.Literal("wait"),
+      ]),
+      message: Type.Optional(Type.String({ maxLength: 12000 })),
+      provider: Type.Optional(Type.String({ maxLength: 120 })),
+      modelId: Type.Optional(Type.String({ maxLength: 240 })),
+      thinkingLevel: Type.Optional(Type.String({ maxLength: 40 })),
+      compactInstructions: Type.Optional(Type.String({ maxLength: 12000 })),
+      timeoutMs: Type.Optional(Type.Number({ minimum: 500, maximum: 1800000 })),
+    }),
+    async execute(_toolCallId, params) {
+      try {
+        const action = String(params.action || "status");
+        const result = action === "status"
+          ? { ok: true, action, ...RPC_POOL.status() }
+          : await RPC_POOL.controlActive(action, {
+              message: params.message,
+              provider: params.provider,
+              modelId: params.modelId,
+              level: params.thinkingLevel,
+              customInstructions: params.compactInstructions,
+              timeoutMs: params.timeoutMs,
+            });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+          isError: result?.ok === false,
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: message }],
+          details: { action: params.action, error: message },
+          isError: true,
+        };
+      }
+    },
+  });
+
   const uesExecuteTool: any = {
     name: "ues_execute",
     label: "UES Execute",
@@ -3212,7 +3920,13 @@ export default function (pi: ExtensionAPI) {
       const cwd = requireGitWorkspaceRoot(params.cwd || ctx.cwd, "ues_execute");
       const inheritedModel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
       const inheritedThinking = ctx.thinkingLevel as string | undefined;
-      const inheritedDirty = captureInheritedDirtyState(cwd);
+      const controllerWorkspaceState = captureWorkspaceStateV2(cwd);
+      const inheritedDirty = captureInheritedDirtyState(cwd, {
+        workspaceState: controllerWorkspaceState,
+      });
+      const controllerHygieneBaseline = captureWorkspaceHygieneBaseline(cwd, {
+        workspaceState: controllerWorkspaceState,
+      });
       const executionContract = buildExecutionContract(params.task, inheritedDirty);
       const contractPrompt = executionContractPrompt(executionContract);
       const suppliedPolicy = (params as any).__taskPolicy;
@@ -3243,6 +3957,8 @@ export default function (pi: ExtensionAPI) {
         profile: policy.executionProfile,
         risk: policy.risk,
         mode: policy.mode,
+        decisionConfidence: policy.decision?.confidence ?? null,
+        decisionReason: policy.decision?.reason ?? null,
         inheritedDirtyCount: executionContract.inheritedDirty?.paths?.length || 0,
         explicitPhaseCount: executionContract.phases?.length || 0,
         localEnvWriteExplicitlyAllowed: executionContract.localEnvWriteExplicitlyAllowed === true,
@@ -3430,8 +4146,8 @@ export default function (pi: ExtensionAPI) {
             "",
             "## Acceptance criteria proven",
             deterministicPass
-              ? "All explicitly requested whitelisted Git inspection commands completed successfully."
-              : "The requested deterministic inspection did not fully pass.",
+              ? "VERIFIED: All explicitly requested whitelisted Git inspection commands completed successfully."
+              : "UNKNOWN: The requested deterministic inspection did not fully pass.",
             "",
             "## Failures",
             failureText,
@@ -3491,6 +4207,27 @@ export default function (pi: ExtensionAPI) {
             1,
           );
           if (isAbortedRun(inspection)) return abortedResponse(inspection, "read-only-inspection");
+          if (
+            inspection.exitCode === 0 &&
+            inspection.verdict === "PASS" &&
+            !acceptanceEvidenceStatusPresent(inspection)
+          ) {
+            inspection = await run(
+              "ues-verifier",
+              [
+                "READ-ONLY VERIFICATION FORMAT RECOVERY. The previous verifier returned PASS but omitted mandatory evidence-status prefixes.",
+                "Do not edit files. Re-check only what is needed to support the existing verdict.",
+                "In ## Acceptance criteria proven, prefix every requested criterion with exactly VERIFIED:, INFERRED:, or UNKNOWN:.",
+                "INFERRED or UNKNOWN criteria must also be listed under ## Unresolved gaps and cannot support PASS.",
+                "",
+                "Inspection request:",
+                params.task,
+              ].join("\n"),
+              1,
+              "Previous verifier PASS omitted evidence-status markers.",
+            );
+            if (isAbortedRun(inspection)) return abortedResponse(inspection, "read-only-verification-format-recovery");
+          }
         }
 
         const after = runtimeWorkspaceSnapshot(cwd);
@@ -3505,6 +4242,7 @@ export default function (pi: ExtensionAPI) {
           workspaceSnapshot: after,
           behavioralReceipts: [],
           requireBehavioralReceipt: false,
+          requireClaimEvidenceStatus: true,
         });
         if (!unchanged) {
           completionAudit.passed = false;
@@ -4043,6 +4781,56 @@ export default function (pi: ExtensionAPI) {
             };
           }
 
+          const finalWriteScope = [...new Set(
+            structuredPlan.tasks.flatMap((task: any) => taskWriteFiles(task)),
+          )];
+          const preFinalAudit = await preFinalWorkspaceAudit(cwd, {
+            baseline: controllerHygieneBaseline,
+            taskText: params.task,
+            allowedPaths: finalWriteScope,
+            strictScope: true,
+            allowSourceMutations: true,
+          }).catch((error) => ({
+            safe: false,
+            summary: "pre-final workspace audit failed: " + (error instanceof Error ? error.message : String(error)),
+            findings: [],
+          }));
+          if (!preFinalAudit.safe) {
+            if (durableWork) {
+              await durableRecordIntegration(
+                cwd,
+                durableWork.slug,
+                "PARTIAL",
+                preFinalAudit.summary || "pre-final workspace hygiene failed",
+                signal,
+              ).catch(() => {});
+            }
+            return {
+              content: [{
+                type: "text",
+                text: [
+                  "UES pre-final workspace audit blocked PASS.",
+                  "The final repository contains an undeclared, transient, or Unicode-unsafe change.",
+                  "",
+                  preFinalAudit.summary || "workspace hygiene failed",
+                ].join("\n"),
+              }],
+              details: {
+                mode: "execute",
+                policy,
+                steps,
+                structuredPlan,
+                scheduled,
+                durableWork,
+                verdictMatrix,
+                executionContract,
+                preFinalAudit,
+                traceID,
+              },
+              isError: true,
+            };
+          }
+
           let durableFinalization: any = null;
           if (durableWork) {
             const finalEvidence = finalEvidenceForContract;
@@ -4219,7 +5007,7 @@ export default function (pi: ExtensionAPI) {
             agent: "ues-deterministic-verifier", task: params.task, cwd, exitCode: 0,
             output: ["FAST bounded verification reused fresh behavioral evidence captured at the tool boundary.", ...fastGate.behavioralReceipts.map((item: any) => "- " + item.command), "", "UES_VERDICT: PASS"].join("\n"),
             stderr: "", verdict: "PASS", durationMs: 0, toolCalls: 0, toolNames: [],
-            report: { schemaVersion: 1, valid: true, verdict: "PASS", sections: { "checks-run": fastGate.behavioralReceipts.map((item: any) => item.command).join("\n"), "acceptance-criteria-proven": "Fresh behavioral verification receipt(s) exist at the post-implementation workspace fingerprint.", "completion-evidence": "Deterministic PASS receipt captured after this implementation attempt." } },
+            report: { schemaVersion: 1, valid: true, verdict: "PASS", sections: { "checks-run": fastGate.behavioralReceipts.map((item: any) => item.command).join("\n"), "acceptance-criteria-proven": "VERIFIED: Fresh behavioral verification receipt(s) exist at the post-implementation workspace fingerprint.", "completion-evidence": "Deterministic PASS receipt captured after this implementation attempt." } },
             optimizations: { fastDeterministicVerification: true, behavioralReceiptCount: fastGate.behavioralReceipts.length },
           };
           steps.push(verification);
@@ -4237,6 +5025,30 @@ export default function (pi: ExtensionAPI) {
             ].join("\n"), attempt, recentFailure || undefined,
           );
           if (isAbortedRun(verification)) return abortedResponse(verification, "verification");
+          if (
+            verification.exitCode === 0 &&
+            verification.verdict === "PASS" &&
+            !acceptanceEvidenceStatusPresent(verification)
+          ) {
+            verification = await run(
+              "ues-verifier",
+              [
+                "VERIFICATION FORMAT RECOVERY. The previous verifier returned PASS but omitted mandatory evidence-status prefixes.",
+                "Do not edit files and do not re-run broad checks. Re-check only what is necessary to support the verdict.",
+                "In ## Acceptance criteria proven, prefix every requested criterion with exactly VERIFIED:, INFERRED:, or UNKNOWN:.",
+                "INFERRED or UNKNOWN criteria must also appear under ## Unresolved gaps and cannot support PASS.",
+                "",
+                "Original task:",
+                params.task,
+                "",
+                "Previous verifier output (not proof by itself):",
+                cap(verification.output, 5000),
+              ].join("\n"),
+              attempt,
+              "Previous verifier PASS omitted evidence-status markers.",
+            );
+            if (isAbortedRun(verification)) return abortedResponse(verification, "verification-format-recovery");
+          }
         }
         const verified = verification.exitCode === 0 && verification.verdict === "PASS";
         if (!verified) {
@@ -4323,6 +5135,7 @@ export default function (pi: ExtensionAPI) {
           workspaceSnapshot: completionSnapshot,
           behavioralReceipts: freshReceipts,
           requireBehavioralReceipt: policy.requireBehavioralReceipt !== false,
+          requireClaimEvidenceStatus: true,
         });
         if (!completionAudit.passed) {
           recentFailure = "Completion auditor rejected PASS: " + completionAudit.failures.join(", ");
@@ -4381,6 +5194,37 @@ export default function (pi: ExtensionAPI) {
           };
         }
 
+        const preFinalAudit = await preFinalWorkspaceAudit(cwd, {
+          baseline: controllerHygieneBaseline,
+          taskText: params.task,
+          strictScope: false,
+          allowSourceMutations: true,
+        }).catch((error) => ({
+          safe: false,
+          summary: "pre-final workspace audit failed: " + (error instanceof Error ? error.message : String(error)),
+          findings: [],
+        }));
+        if (!preFinalAudit.safe) {
+          recentFailure = "Pre-final workspace audit rejected PASS: " + (preFinalAudit.summary || "workspace hygiene failed");
+          await recordRuntimeOutcome(implementation, params.task, false, attempt - 1);
+          if (attempt < maxAttempts) continue;
+          return {
+            content: [{ type: "text", text: recentFailure }],
+            details: {
+              mode: "execute",
+              policy,
+              steps,
+              attempts: attempt,
+              completionAudit,
+              verdictMatrix,
+              executionContract,
+              preFinalAudit,
+              traceID,
+            },
+            isError: true,
+          };
+        }
+
         await recordRuntimeOutcome(implementation, params.task, true, attempt - 1);
         const memory = await rememberVerifiedTask(cwd, params.task, verification, integrationResult);
         const final = steps.at(-1);
@@ -4425,9 +5269,17 @@ export default function (pi: ExtensionAPI) {
         "Package root: " + PACKAGE_ROOT,
         "Child runtime: " + CHILD_RUNTIME,
         "Adaptive context: " + (ADAPTIVE_CONTEXT_ENABLED ? "on" : "off"),
+        "Unified workspace snapshot V2: on",
+        "Parallel context preparation: on",
+        "Git-index affected-test inventory: on",
+        "Parallel verification evidence I/O: on",
         "Micro skills: " + (MICRO_SKILLS_ENABLED ? "on" : "off"),
         "Turbo Fast Path: on",
         "Parent UES tools hidden outside UES runs: on",
+        "Parent Code Intelligence Lite: on (always-on read-only ues_code; no controller/child)",
+        "Native Pi RPC session control: on (state/steer/follow-up/abort/model/thinking/compact/wait)",
+        "Permission deny-and-continue recovery: on",
+        "Provider empty-response recovery: on (per-incident parent retry + bounded total + child RPC recovery; no blind replay after tools)",
         "Zero-friction engineering admission: " + (AUTO_ADMISSION_ENABLED ? "on (native / auto / high-risk + safe continuation)" : "off"),
         "Git-root artifact guard: on",
         "Inherited dirty-work guard: on",
@@ -4435,6 +5287,9 @@ export default function (pi: ExtensionAPI) {
         "Portable temp-path guard: on",
         "Explicit phase barriers: on",
         "Independent final verdict matrix: on",
+        "Unicode source hygiene: blocking bidi/zero-width/control/homoglyph audit",
+        "Post-run file hygiene: transient cleanup + read-only mutation guard",
+        "Pre-final workspace audit: on",
         "Disk hygiene: bounded + auto-clean",
         "Writer concurrency: " + MAX_WRITER_CONCURRENCY,
       ].join("\n");
@@ -4766,9 +5621,11 @@ export default function (pi: ExtensionAPI) {
     name: "ues_dispatch",
     label: "UES Dispatch",
     description:
-      "Run bundled UES specialist agents in isolated child Pi processes. Supports single, parallel, or chain mode. Parallel writer agents fail closed unless each writer has an explicit distinct cwd/worktree. Available agents: " +
+      "Run bundled UES specialist agents in isolated child Pi processes, or inspect durable child handles with action=status/list. Every child run writes a small artifact with exact task/output evidence references. Supports single, parallel, or chain mode. Parallel writer agents fail closed unless each writer has an explicit distinct cwd/worktree. Available agents: " +
       Object.keys(AGENTS).join(", "),
     parameters: Type.Object({
+      action: Type.Optional(Type.Union([Type.Literal("run"), Type.Literal("status"), Type.Literal("list")])),
+      handle: Type.Optional(Type.String({ description: "Subagent artifact handle for status action" })),
       agent: Type.Optional(Type.String({ description: "Agent name for single mode" })),
       task: Type.Optional(Type.String({ description: "Task for single mode" })),
       cwd: Type.Optional(Type.String({ description: "Working directory for single mode" })),
@@ -4777,6 +5634,39 @@ export default function (pi: ExtensionAPI) {
     }),
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       refreshHostBrowserToolNames(pi);
+      const action = String(params.action || "run");
+      const baseCwd = ctx.cwd;
+      if (action === "status") {
+        if (!params.handle) {
+          return {
+            content: [{ type: "text", text: "ues_dispatch action=status requires handle." }],
+            details: { mode: "status" },
+            isError: true,
+          };
+        }
+        try {
+          const root = requireGitWorkspaceRoot(baseCwd, "ues_dispatch status");
+          const artifact = await readSubagentArtifact(root, params.handle);
+          return {
+            content: [{ type: "text", text: JSON.stringify(artifact, null, 2) }],
+            details: { mode: "status", artifact },
+          };
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+            details: { mode: "status", handle: params.handle },
+            isError: true,
+          };
+        }
+      }
+      if (action === "list") {
+        const root = requireGitWorkspaceRoot(baseCwd, "ues_dispatch list");
+        const artifacts = await listSubagentArtifacts(root, { limit: 20 });
+        return {
+          content: [{ type: "text", text: JSON.stringify(artifacts, null, 2) }],
+          details: { mode: "list", artifacts },
+        };
+      }
       const hasSingle = Boolean(params.agent && params.task);
       const hasParallel = Boolean(params.tasks?.length);
       const hasChain = Boolean(params.chain?.length);
@@ -4791,7 +5681,6 @@ export default function (pi: ExtensionAPI) {
       const validateAgent = (name: string): name is AgentName => name in AGENTS;
       const model = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
       const thinking = ctx.thinkingLevel as string | undefined;
-      const baseCwd = ctx.cwd;
 
       if (hasSingle) {
         if (!validateAgent(params.agent!)) {