opencode-agent-skill 14.4.0 → 15.0.0

package/pi/extensions/ues.ts

@@ -7,15 +7,16 @@ import { fileURLToPath } from "node:url";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { destructiveShellRisk } from "../../lib/safety.mjs";
-import { classifyEngineeringTask, shouldRunDedicatedDiagnosis } from "../../lib/task-policy.mjs";
+import { automaticUesAdmission, automaticUesContinuation, classifyEngineeringTask, deterministicReadOnlyGitCommands, shouldRunDedicatedDiagnosis } from "../../lib/task-policy.mjs";
 import { resolveCapabilityModel } from "../../lib/model-policy.mjs";
 import { readModelPolicy, recordModelPerformance } from "../../lib/model-config.mjs";
 import { getUesConfigDir } from "../../lib/runtime-config.mjs";
 import { buildAdaptiveTaskContext } from "../../lib/context-engine-v11.mjs";
 import { recordVerifiedTaskMemory } from "../../lib/memory-engine.mjs";
-import { computeSafeWaves, taskVerificationCommands, taskWriteFiles, validatePlan } from "../../lib/task-graph.mjs";
+import { computeSafeWaves, normalizePlanForValidation, taskVerificationCommands, taskWriteFiles, validatePlan } from "../../lib/task-graph.mjs";
 import { planDynamicWorkflow } from "../../lib/dynamic-workflow.mjs";
 import { compactReversibleOutput } from "../../lib/performance-fabric.mjs";
+import { gcEvidenceStore } from "../../lib/evidence-store.mjs";
 import {
   createToolOutputAccumulator,
   detectHungToolEvidence,
@@ -24,11 +25,21 @@ import {
 } from "../../lib/process-hang-detector.mjs";
 import { runSupervisedProcess, terminateProcessTree } from "../../lib/process-supervisor.mjs";
 import { PiRpcWorkerPool } from "../../lib/pi-rpc-pool.mjs";
+import { resolvePiChildInvocation } from "../../lib/pi-child-invocation.mjs";
 import { adaptiveContextBudget } from "../../lib/adaptive-context-budget.mjs";
 import { clearSkillCompilerCache, compileSkillContext } from "../../lib/skill-compiler.mjs";
 import { clearAffectedTestCache, resolveAffectedTests } from "../../lib/affected-tests.mjs";
 import { findReusableVerification, listReusableVerification, recordVerification } from "../../lib/verification-broker.mjs";
 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 { planningRuntimeBudget, shouldSoftSteerArchitect, shouldSoftSteerPlanningRole } from "../../lib/planning-speed-policy.mjs";
+import { sourceFacingPaths, sourceGitPathspecs } from "../../lib/runtime-artifacts.mjs";
+import { buildExecutionContract, buildFinalVerdictMatrix, captureInheritedDirtyState, detectInheritedDirtyViolations, enforcePhaseGates, executionContractPrompt, phaseArtifactPayloads, taskExplicitlyAllowsLocalEnvWrite } from "../../lib/execution-contract.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 { McpHealthTracker } from "../../lib/mcp-health.mjs";
@@ -47,14 +58,37 @@ import {
   integrateTaskSandbox,
   removeTaskSandbox,
   rollbackTaskSandbox,
+  pruneOrphanTaskSandboxes,
+  taskSandboxOwnerRoot,
 } from "../../lib/worktree-sandbox.mjs";
+import {
+  looksLikeLongRunningServiceCommand,
+  restartService,
+  serviceLogs,
+  serviceStatus,
+  startService,
+  stopAllServices,
+  stopService,
+  waitForService,
+} from "../../lib/service-manager.mjs";
 
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const PACKAGE_VERSION = (() => {
+  try {
+    return String(JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"))?.version || "unknown");
+  } catch {
+    return "unknown";
+  }
+})();
 const OCSKILL_BIN = path.join(PACKAGE_ROOT, "bin", "ocskill.mjs");
 const CHILD_RUNTIME_EXTENSION = path.join(PACKAGE_ROOT, "pi", "extensions", "ues-child-runtime.ts");
 const AGENT_DIR = path.join(PACKAGE_ROOT, "global-config", "agents");
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
+const MAX_WRITER_CONCURRENCY = Math.max(
+  1,
+  Math.min(4, Number(process.env.UES_MAX_WRITER_CONCURRENCY || (process.platform === "win32" ? 2 : 3))),
+);
 const OUTPUT_LIMIT = 512 * 1024;
 
 function configuredDuration(name: string, fallback: number, min: number, max: number) {
@@ -93,6 +127,12 @@ const POST_TOOL_ERROR_IDLE_TIMEOUT_MS = configuredDuration(
   5_000,
   5 * 60_000,
 );
+const TURBO_FAST_TIMEOUTS = turboFastTimeoutBudget({
+  hardTimeoutMs: configuredDuration("UES_FAST_CHILD_HARD_TIMEOUT_MS", 180_000, 30_000, 10 * 60_000),
+  idleTimeoutMs: configuredDuration("UES_FAST_CHILD_IDLE_TIMEOUT_MS", 60_000, 20_000, 5 * 60_000),
+  postToolErrorIdleTimeoutMs: configuredDuration("UES_FAST_POST_TOOL_ERROR_IDLE_TIMEOUT_MS", 30_000, 5_000, 2 * 60_000),
+  verificationTimeoutSec: configuredDuration("UES_FAST_VERIFICATION_TIMEOUT_SEC", 90, 30, 300),
+});
 const MODEL_VISIBLE_OUTPUT_LIMIT = configuredDuration(
   "UES_MODEL_VISIBLE_OUTPUT_LIMIT",
   64 * 1024,
@@ -160,6 +200,7 @@ function abortActiveCliChildren() {
 
 let HOST_BROWSER_TOOL_NAMES: string[] = [];
 const CONTEXT_PACK_CACHE = new Map<string, any>();
+const ACTIVE_TASK_SANDBOXES = new Map<string, string>();
 
 function configuredBrowserToolNames() {
   return String(process.env.UES_BROWSER_MCP_TOOL_NAMES || "")
@@ -257,6 +298,8 @@ function getAgentPrompt(agent: AgentName) {
     "- Do not call OpenCode-only dispatch tools such as \`ues.dispatch_task\` or \`ues.dispatch_parallel\`.",
     "- Respect the original role's edit/read-only boundary and return evidence to the parent Pi session.",
     "- Prefer ues_code for bounded semantic/AST search, hash-anchored reads and optional LSP diagnostics. Writer roles may use ues_code_edit only after an anchored read; stale anchors must be re-read rather than fuzzily retried.",
+    "- Never launch a persistent dev server/watcher in foreground bash/powershell. Use ues_service start, wait-ready/status/logs, then stop; the runtime blocks common foreground-service commands to prevent hangs.",
+    "- On Windows, never pass /tmp or /var/tmp paths between Pi file tools and bash/powershell: their path namespaces may differ. Keep temporary transforms inside one shell pipeline, or use an ignored repository-local scratch path such as .ues-cache/tmp for cross-tool scratch.",
     "- For PDF/DOCX/PPTX/XLSX evidence, ues_code action=document may use optional MarkItDown when installed; do not install it unless that capability is needed.",
     "",
   ].join("\n");
@@ -272,16 +315,8 @@ function getAgentPrompt(agent: AgentName) {
 }
 
 function getPiInvocation(args: string[]): { command: string; args: string[] } {
-  const currentScript = process.argv[1];
-  const isBunVirtualScript = currentScript?.startsWith("/$bunfs/root/");
-  if (currentScript && !isBunVirtualScript && fs.existsSync(currentScript)) {
-    return { command: process.execPath, args: [currentScript, ...args] };
-  }
-
-  const execName = path.basename(process.execPath).toLowerCase();
-  const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
-  if (!isGenericRuntime) return { command: process.execPath, args };
-  return { command: "pi", args };
+  const invocation = resolvePiChildInvocation(args);
+  return { command: invocation.command, args: invocation.args };
 }
 
 function extractAssistantText(message: any): string {
@@ -345,6 +380,83 @@ async function runOcskillJson(args: string[], cwd: string, signal?: AbortSignal)
   }
 }
 
+async function persistExecutionContractArtifacts(dir: string, contract: any) {
+  if (!contract || !dir) return null;
+  const phasesDir = path.join(dir, "phases");
+  await fs.promises.mkdir(phasesDir, { recursive: true });
+  await fs.promises.writeFile(
+    path.join(dir, "EXECUTION_CONTRACT.json"),
+    JSON.stringify(contract, null, 2) + "\n",
+    "utf8",
+  );
+  await fs.promises.writeFile(
+    path.join(phasesDir, "MANIFEST.json"),
+    JSON.stringify({
+      schemaVersion: 1,
+      taskHash: contract.taskHash,
+      phaseCount: contract.phases?.length || 0,
+      artifacts: phaseArtifactPayloads(contract).map((item: any) => item.file),
+    }, null, 2) + "\n",
+    "utf8",
+  );
+  for (const item of phaseArtifactPayloads(contract)) {
+    const target = path.join(dir, item.file);
+    await fs.promises.mkdir(path.dirname(target), { recursive: true });
+    await fs.promises.writeFile(target, JSON.stringify(item.value, null, 2) + "\n", "utf8");
+  }
+  return {
+    contract: path.join(dir, "EXECUTION_CONTRACT.json"),
+    manifest: path.join(phasesDir, "MANIFEST.json"),
+    phaseCount: contract.phases?.length || 0,
+  };
+}
+
+async function finalizeExecutionContractArtifacts(
+  dir: string,
+  contract: any,
+  verdictMatrix: any,
+  evidence: string,
+) {
+  if (!dir || !contract) return null;
+  const payload = {
+    schemaVersion: 1,
+    verdictMatrix,
+    evidence: cap(evidence || "", 12000),
+    finalizedAt: new Date().toISOString(),
+  };
+  await fs.promises.writeFile(
+    path.join(dir, "FINAL_VERDICTS.json"),
+    JSON.stringify(payload, null, 2) + "\n",
+    "utf8",
+  );
+
+  for (const item of phaseArtifactPayloads(contract)) {
+    const phaseText = String(item.value.title || "") + "\n" + String(item.value.sourceBody || "");
+    let status = verdictMatrix?.source === "SOURCE_PASS" ? "VERIFIED" : "NOT_VERIFIED";
+    if (/device|expo go|thiết bị/i.test(phaseText) && verdictMatrix?.device !== "DEVICE_PASS") {
+      status = "NOT_VERIFIED";
+    }
+    if (/(?:cleanup|fixture|database|db|dữ liệu)/i.test(phaseText) && contract.gates?.dbClean === true && verdictMatrix?.dbClean !== "DB_CLEAN_PASS") {
+      status = "NOT_VERIFIED";
+    }
+    if (/(?:runtime|smoke|e2e|integration|typecheck|lint|test|verify|xác minh|kiểm tra)/i.test(phaseText) && contract.gates?.runtime === true && verdictMatrix?.runtime !== "RUNTIME_PASS") {
+      status = "NOT_VERIFIED";
+    }
+    const target = path.join(dir, item.file);
+    await fs.promises.writeFile(
+      target,
+      JSON.stringify({
+        ...item.value,
+        status,
+        finalVerdicts: verdictMatrix,
+        evidence: [cap(evidence || "", 6000)],
+      }, null, 2) + "\n",
+      "utf8",
+    );
+  }
+  return payload;
+}
+
 async function initializeDurableControllerWork(
   root: string,
   originalTask: string,
@@ -540,9 +652,22 @@ async function runAgentCli(
     compactToolOutput?: boolean;
     toolOutputLimit?: number;
     verificationTimeoutSec?: number;
+    hardTimeoutMs?: number;
+    absoluteHardTimeoutMs?: number;
+    activityExtensionMs?: number;
+    activityWindowMs?: number;
+    idleTimeoutMs?: number;
+    postToolErrorIdleTimeoutMs?: number;
+    allowLocalEnvWrite?: boolean;
   } = {},
 ): Promise<RunResult> {
   const config = AGENTS[agent];
+  const hardTimeoutMs = Number(runtimeOptions.hardTimeoutMs || CHILD_HARD_TIMEOUT_MS);
+  const absoluteHardTimeoutMs = Number(runtimeOptions.absoluteHardTimeoutMs || hardTimeoutMs);
+  const activityExtensionMs = Number(runtimeOptions.activityExtensionMs || 0);
+  const activityWindowMs = Number(runtimeOptions.activityWindowMs || Math.max(5_000, Math.min(activityExtensionMs || hardTimeoutMs, 30_000)));
+  const idleTimeoutMs = Number(runtimeOptions.idleTimeoutMs || CHILD_IDLE_TIMEOUT_MS);
+  const postToolErrorIdleTimeoutMs = Number(runtimeOptions.postToolErrorIdleTimeoutMs || POST_TOOL_ERROR_IDLE_TIMEOUT_MS);
   const args: string[] = [
     "--mode", "json", "-p", "--no-session",
     // Keep extension discovery enabled so custom model providers (for example
@@ -559,6 +684,7 @@ async function runAgentCli(
   const allowedTools = [...new Set([
     ...config.tools,
     ...codeIntelligenceTools,
+    "ues_service",
     ...extraTools,
     ...(runtimeOptions.compactToolOutput ? ["ues_evidence_get"] : []),
   ])];
@@ -588,9 +714,11 @@ async function runAgentCli(
         env: {
           ...process.env,
           UES_CHILD_PROCESS: "1",
+          UES_CHILD_AGENT: agent,
           UES_CHILD_TOOL_COMPACTION: runtimeOptions.compactToolOutput ? "1" : "0",
           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",
         },
         shell: false,
         detached: process.platform !== "win32",
@@ -599,6 +727,12 @@ async function runAgentCli(
       });
       const childStartedAt = Date.now();
       let lastActivityAt = childStartedAt;
+      const adaptiveDeadline = createAdaptiveDeadline({
+        hardTimeoutMs,
+        absoluteHardTimeoutMs,
+        activityExtensionMs,
+        activityWindowMs,
+      }, childStartedAt);
       let buffer = "";
       let settled = false;
       let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
@@ -722,19 +856,20 @@ async function runAgentCli(
       heartbeatTimer.unref?.();
       watchdogTimer = setInterval(() => {
         const now = Date.now();
-        if (now - childStartedAt >= CHILD_HARD_TIMEOUT_MS) {
+        const deadline = adaptiveDeadline.shouldAbort(now, lastActivityAt);
+        if (deadline.abort) {
           terminateForTimeout("hard");
           return;
         }
         if (
           lastToolErrorAt > 0 &&
-          now - lastToolErrorAt >= POST_TOOL_ERROR_IDLE_TIMEOUT_MS &&
-          now - lastActivityAt >= POST_TOOL_ERROR_IDLE_TIMEOUT_MS
+          now - lastToolErrorAt >= postToolErrorIdleTimeoutMs &&
+          now - lastActivityAt >= postToolErrorIdleTimeoutMs
         ) {
           terminateForTimeout("post-tool-error");
           return;
         }
-        if (now - lastActivityAt >= CHILD_IDLE_TIMEOUT_MS) {
+        if (now - lastActivityAt >= idleTimeoutMs) {
           terminateForTimeout("idle");
         }
       }, 1000);
@@ -787,8 +922,13 @@ async function runAgentCli(
               lastToolErrorEvidence = "";
             }
           }
-          if (event.type === "message_update" && event.usage) {
-            usage = event.usage;
+          if (event.type === "message_update") {
+            if (event.usage) usage = event.usage;
+            if (event.message?.role === "assistant") {
+              const partial = extractAssistantText(event.message);
+              if (partial) output = partial;
+              seenModel = event.message.model || seenModel;
+            }
           }
           if (event.type === "message_end" && event.message) {
             const text = extractAssistantText(event.message);
@@ -897,9 +1037,22 @@ async function runAgentRpc(
     compactToolOutput?: boolean;
     toolOutputLimit?: number;
     verificationTimeoutSec?: number;
+    hardTimeoutMs?: number;
+    absoluteHardTimeoutMs?: number;
+    activityExtensionMs?: number;
+    activityWindowMs?: number;
+    idleTimeoutMs?: number;
+    postToolErrorIdleTimeoutMs?: number;
+    allowLocalEnvWrite?: boolean;
   } = {},
 ): Promise<RunResult> {
   const config = AGENTS[agent];
+  const hardTimeoutMs = Number(runtimeOptions.hardTimeoutMs || CHILD_HARD_TIMEOUT_MS);
+  const absoluteHardTimeoutMs = Number(runtimeOptions.absoluteHardTimeoutMs || hardTimeoutMs);
+  const activityExtensionMs = Number(runtimeOptions.activityExtensionMs || 0);
+  const activityWindowMs = Number(runtimeOptions.activityWindowMs || Math.max(5_000, Math.min(activityExtensionMs || hardTimeoutMs, 30_000)));
+  const idleTimeoutMs = Number(runtimeOptions.idleTimeoutMs || CHILD_IDLE_TIMEOUT_MS);
+  const postToolErrorIdleTimeoutMs = Number(runtimeOptions.postToolErrorIdleTimeoutMs || POST_TOOL_ERROR_IDLE_TIMEOUT_MS);
   const args: string[] = [
     "--mode", "rpc", "--no-session",
     "--no-skills", "--no-prompt-templates", "--no-context-files",
@@ -907,8 +1060,13 @@ async function runAgentRpc(
   ];
   if (model) args.push("--model", model);
   if (thinkingLevel) args.push("--thinking", thinkingLevel);
+  const codeIntelligenceTools = WRITE_AGENTS.has(agent)
+    ? ["ues_code", "ues_code_edit"]
+    : ["ues_code"];
   const allowedTools = [...new Set([
     ...config.tools,
+    ...codeIntelligenceTools,
+    "ues_service",
     ...extraTools,
     ...(runtimeOptions.compactToolOutput ? ["ues_evidence_get"] : []),
   ])];
@@ -924,6 +1082,7 @@ async function runAgentRpc(
     Boolean(runtimeOptions.compactToolOutput),
     Number(runtimeOptions.toolOutputLimit || 0),
     Number(runtimeOptions.verificationTimeoutSec || 0),
+    Boolean(runtimeOptions.allowLocalEnvWrite),
   ]);
   const taskInput = `Task: ${task}\n`;
   const startedAt = Date.now();
@@ -960,17 +1119,22 @@ async function runAgentRpc(
         env: {
           ...process.env,
           UES_CHILD_PROCESS: "1",
+          UES_CHILD_AGENT: agent,
           UES_CHILD_TOOL_COMPACTION: runtimeOptions.compactToolOutput ? "1" : "0",
           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",
         },
       },
       taskInput,
       {
         signal,
-        hardTimeoutMs: CHILD_HARD_TIMEOUT_MS,
-        idleTimeoutMs: CHILD_IDLE_TIMEOUT_MS,
-        postToolErrorIdleTimeoutMs: POST_TOOL_ERROR_IDLE_TIMEOUT_MS,
+        hardTimeoutMs,
+        absoluteHardTimeoutMs,
+        activityExtensionMs,
+        activityWindowMs,
+        idleTimeoutMs,
+        postToolErrorIdleTimeoutMs,
         onEvent: (event: any) => {
           lastActivityAt = Date.now();
           if (event.type === "tool_execution_start") {
@@ -1072,12 +1236,16 @@ async function runAgentRpc(
     if ((error as any)?.uesRpcPhase === "runtime") {
       const timeout = /hard-timeout|idle-timeout/i.test(message);
       const toolStall = /post-tool-error-stall/i.test(message);
+      const partialOutput = extractAssistantText((error as any)?.partialMessage);
+      const recoveredOutput = partialOutput
+        ? partialOutput + "\n\n[UES transport note: " + message + "]"
+        : message;
       return {
         agent,
         task,
         cwd,
         exitCode: timeout ? 124 : toolStall ? 125 : 1,
-        output: message,
+        output: recoveredOutput,
         stderr: message,
         model,
         stopReason: timeout ? "timeout" : toolStall ? "tool-error-stall" : "rpc-runtime-error",
@@ -1109,6 +1277,13 @@ async function runAgent(
     compactToolOutput?: boolean;
     toolOutputLimit?: number;
     verificationTimeoutSec?: number;
+    hardTimeoutMs?: number;
+    absoluteHardTimeoutMs?: number;
+    activityExtensionMs?: number;
+    activityWindowMs?: number;
+    idleTimeoutMs?: number;
+    postToolErrorIdleTimeoutMs?: number;
+    allowLocalEnvWrite?: boolean;
   } = {},
 ): Promise<RunResult> {
   if (CHILD_RUNTIME !== "cli") {
@@ -1251,9 +1426,37 @@ function cachedContextKey(
   role: string,
   budget: number,
   fingerprint = "unknown",
+  namespace = cwd,
 ) {
   const auxStamp = runtimeContextAuxStamp(cwd);
-  return [cwd, fingerprint, auxStamp, role, String(budget), task].join("\u0000");
+  return [path.resolve(namespace), fingerprint, auxStamp, role, String(budget), task].join("\u0000");
+}
+
+function deepExplorationContract(role: string) {
+  const common = [
+    "## UES DEEP bounded exploration",
+    "Quality gates remain unchanged. Reduce latency by avoiding duplicate discovery, not by skipping evidence.",
+    "Use the supplied runtime context pack, hierarchy, ranked references and declared files before broad repository exploration.",
+    "Prefer targeted ues_code/direct reads. Do not inventory the repository or repeat unchanged reads unless a named evidence gap requires it.",
+  ];
+  if (role === "architect") {
+    common.push(
+      "Stop exploring once every planned task has exact repository-relative scope, dependency ordering, observable acceptance, concrete verification, and risk/rollback coverage.",
+    );
+  } else if (role === "plan-checker") {
+    common.push(
+      "Inspect only disputed or unproven plan properties; once each blocking property is proven or rejected, return PASS/REVISE immediately.",
+    );
+  } else if (role === "executor") {
+    common.push(
+      "Start with declared task files and direct consumers/tests only. Once the safe minimal edit is supported by evidence, implement and spend remaining effort on fresh verification rather than more discovery.",
+    );
+  } else if (role === "debugger") {
+    common.push(
+      "Investigate only the concrete failure path and nearest evidence needed to reject/confirm the active hypothesis; avoid general repository surveys.",
+    );
+  }
+  return common.join("\n");
 }
 
 function compactContextPack(pack: any, recentFailure?: string) {
@@ -1304,20 +1507,23 @@ async function runRoutedAgent(
   signal?: AbortSignal,
   onProgress?: Parameters<typeof runAgent>[6],
   traceID?: string,
+  taskPolicyOverride?: any,
+  contextCacheNamespace?: string,
 ): Promise<RunResult> {
   const role = roleForAgent(agent);
+  const traceRoot = requireGitWorkspaceRoot(cwd, "UES specialist");
   const browserRequested = browserEvidenceNeeded(task, role);
   const browserTools = browserRequested
     ? selectBrowserToolsForTask(HOST_BROWSER_TOOL_NAMES, task, role)
     : [];
-  const taskPolicy = classifyEngineeringTask(task);
-  const fastBoundedContext =
-    attempt === 1 &&
-    taskPolicy.executionProfile === "fast" &&
-    taskPolicy.singleFileBounded === true &&
-    taskPolicy.risk === "low" &&
-    ["executor", "verifier"].includes(role) &&
-    !browserRequested;
+  const taskPolicy = taskPolicyOverride || classifyEngineeringTask(task);
+  const turboFast = turboFastPathDecision(taskPolicy, {
+    role,
+    attempt,
+    browserRequested,
+    visualRequired: visualEvidenceNeeded(task),
+  });
+  const fastBoundedContext = turboFast.eligible;
   const budgetDecision = adaptiveContextBudget(taskPolicy, role, attempt, {
     disabled: !ADAPTIVE_CONTEXT_ENABLED,
   });
@@ -1332,7 +1538,7 @@ async function runRoutedAgent(
   const modelPolicy = await readModelPolicy(getUesConfigDir());
   const selection = resolveCapabilityModel(role, attempt, task, taskPolicy, modelPolicy);
   if (traceID) {
-    await appendTrajectoryEvent(cwd, traceID, "agent.started", {
+    await appendTrajectoryEvent(traceRoot, traceID, "agent.started", {
       agent,
       role,
       attempt,
@@ -1397,12 +1603,17 @@ async function runRoutedAgent(
           : "Verify every explicit acceptance clause independently. Read the final diff/target file, then run a narrow behavioral check. Compilation or syntax alone is not proof. If any enumerated edge/error/idempotency/non-mutation case lacks fresh executable evidence, return FAIL.",
       ].join("\n");
     } else {
+    const cacheBudgetKey =
+      ["architect", "plan-checker"].includes(role)
+        ? Number(budgetDecision.baseBudget || budgetDecision.budget)
+        : budgetDecision.budget;
     const cacheKey = cachedContextKey(
       cwd,
       task,
       role,
-      budgetDecision.budget,
+      cacheBudgetKey,
       workspaceFingerprint,
+      contextCacheNamespace || cwd,
     );
     const cacheableContext =
       workspaceState.cacheable === true &&
@@ -1431,8 +1642,9 @@ async function runRoutedAgent(
           cwd,
           task,
           role,
-          budgetDecision.budget,
+          cacheBudgetKey,
           workspaceFingerprint,
+          contextCacheNamespace || cwd,
         );
         if (postBuildKey !== cacheKey) rememberContextPack(postBuildKey, pack);
       }
@@ -1499,6 +1711,10 @@ async function runRoutedAgent(
             row.stdoutPreview ? `  preview: ${cap(String(row.stdoutPreview).replace(/\s+/g, " "), 900)}` : "",
           ].filter(Boolean).join("\n")).join("\n")
         : "",
+      taskPolicy.executionProfile === "deep" &&
+      ["architect", "plan-checker", "executor", "debugger"].includes(role)
+        ? "\n" + deepExplorationContract(role)
+        : "",
     ].filter(Boolean).join("\n");
     }
   } catch (error) {
@@ -1525,6 +1741,11 @@ async function runRoutedAgent(
         ].join("\n");
   }
 
+  const planningBudget = planningRuntimeBudget(role, attempt, {
+    executionProfile: taskPolicy.executionProfile,
+    risk: taskPolicy.risk,
+    taskChars: task.length,
+  });
   const startedAt = Date.now();
   const result = await runAgent(
     agent,
@@ -1546,13 +1767,40 @@ async function runRoutedAgent(
             ? 24 * 1024
             : 48 * 1024,
       verificationTimeoutSec:
-        taskPolicy.risk === "high"
-          ? 900
-          : taskPolicy.executionProfile === "fast"
-            ? 120
-            : taskPolicy.executionProfile === "standard"
-              ? 300
-              : 600,
+        turboFast.eligible
+          ? TURBO_FAST_TIMEOUTS.verificationTimeoutSec
+          : taskPolicy.risk === "high"
+            ? 900
+            : taskPolicy.executionProfile === "fast"
+              ? 120
+              : taskPolicy.executionProfile === "standard"
+                ? 300
+                : 600,
+      hardTimeoutMs:
+        turboFast.eligible
+          ? TURBO_FAST_TIMEOUTS.hardTimeoutMs
+          : planningBudget?.hardTimeoutMs || CHILD_HARD_TIMEOUT_MS,
+      absoluteHardTimeoutMs:
+        turboFast.eligible
+          ? TURBO_FAST_TIMEOUTS.hardTimeoutMs
+          : planningBudget?.absoluteHardTimeoutMs || CHILD_HARD_TIMEOUT_MS,
+      activityExtensionMs:
+        turboFast.eligible ? 0 : planningBudget?.activityExtensionMs || 0,
+      activityWindowMs:
+        turboFast.eligible ? 0 : planningBudget?.activityWindowMs || 0,
+      idleTimeoutMs:
+        turboFast.eligible
+          ? TURBO_FAST_TIMEOUTS.idleTimeoutMs
+          : planningBudget?.idleTimeoutMs || CHILD_IDLE_TIMEOUT_MS,
+      postToolErrorIdleTimeoutMs:
+        turboFast.eligible
+          ? TURBO_FAST_TIMEOUTS.postToolErrorIdleTimeoutMs
+          : planningBudget?.idleTimeoutMs
+            ? Math.min(POST_TOOL_ERROR_IDLE_TIMEOUT_MS, planningBudget.idleTimeoutMs)
+            : POST_TOOL_ERROR_IDLE_TIMEOUT_MS,
+      allowLocalEnvWrite:
+        taskPolicy.localEnvWriteExplicitlyAllowed === true ||
+        taskExplicitlyAllowsLocalEnvWrite(task),
     },
   );
   const enrichedResult: RunResult = {
@@ -1581,13 +1829,17 @@ async function runRoutedAgent(
         !["high", "critical"].includes(String(taskPolicy.risk || "").toLowerCase()),
       runtimeContextBudget: budgetDecision.budget,
       baseContextBudget: budgetDecision.baseBudget,
+      turboFastPath: turboFast.eligible,
+      turboFastStrategy: turboFast.strategy,
+      turboFastTimeouts: turboFast.eligible ? TURBO_FAST_TIMEOUTS : null,
+      planningRuntimeBudget: planningBudget,
     },
     verdict: verdictFromOutput(result.output),
     report: parseStructuredReport(result.output),
     durationMs: Date.now() - startedAt,
   };
   if (traceID) {
-    await appendTrajectoryEvent(cwd, traceID, "agent.completed", {
+    await appendTrajectoryEvent(traceRoot, traceID, "agent.completed", {
       agent,
       role,
       attempt,
@@ -1683,19 +1935,64 @@ function extractMarkedJson(output: string, marker: string) {
   return null;
 }
 
-async function sandboxChangedFiles(dir: string, base: string, signal?: AbortSignal) {
-  const intent = await runProcess("git", ["add", "-N", "."], dir, signal);
-  if (intent.exitCode !== 0) {
-    throw new Error(intent.stderr || intent.stdout || "git add -N failed");
+function sandboxSourceIntentBatches(values: string[]) {
+  const batches: string[][] = [];
+  let batch: string[] = [];
+  let chars = 0;
+  for (const value of sourceFacingPaths(values)) {
+    const cost = value.length + 3;
+    if (batch.length && (batch.length >= 64 || chars + cost > 12_000)) {
+      batches.push(batch);
+      batch = [];
+      chars = 0;
+    }
+    batch.push(value);
+    chars += cost;
   }
-  const diff = await runProcess("git", ["diff", "--name-only", base, "--"], dir, signal);
+  if (batch.length) batches.push(batch);
+  return batches;
+}
+
+async function sandboxIntentToAddSourceFiles(dir: string, signal?: AbortSignal) {
+  const pathspecs = sourceGitPathspecs();
+  const untracked = await runProcess(
+    "git",
+    ["ls-files", "--others", "--exclude-standard", "-z", "--", ...pathspecs],
+    dir,
+    signal,
+  );
+  if (untracked.exitCode !== 0) {
+    throw new Error(untracked.stderr || untracked.stdout || "git ls-files for intent-to-add failed");
+  }
+
+  const candidates = sourceFacingPaths(
+    untracked.stdout
+      .split("\0")
+      .map((value) => value.replaceAll("\\", "/"))
+      .filter(Boolean),
+  );
+  for (const batch of sandboxSourceIntentBatches(candidates)) {
+    const intent = await runProcess("git", ["add", "-N", "--", ...batch], dir, signal);
+    if (intent.exitCode !== 0) {
+      throw new Error(intent.stderr || intent.stdout || "git add -N failed");
+    }
+  }
+  return candidates;
+}
+
+async function sandboxChangedFiles(dir: string, base: string, signal?: AbortSignal) {
+  const pathspecs = sourceGitPathspecs();
+  await sandboxIntentToAddSourceFiles(dir, signal);
+  const diff = await runProcess("git", ["diff", "--name-only", base, "--", ...pathspecs], dir, signal);
   if (diff.exitCode !== 0) {
     throw new Error(diff.stderr || diff.stdout || "git diff --name-only failed");
   }
-  return diff.stdout
-    .split(/\r?\n/)
-    .map((value) => value.trim().replaceAll("\\", "/"))
-    .filter(Boolean);
+  return sourceFacingPaths(
+    diff.stdout
+      .split(/\r?\n/)
+      .map((value) => value.trim().replaceAll("\\", "/"))
+      .filter(Boolean),
+  );
 }
 
 async function cleanupSandboxes(
@@ -1704,19 +2001,39 @@ async function cleanupSandboxes(
 ) {
   for (const item of prepared) {
     if (!item.sandbox?.dir) continue;
-    await removeTaskSandbox(root, item.sandbox.dir, {
-      force: true,
-      deleteBranch: true,
-    }).catch(() => {});
+    const resolved = path.resolve(item.sandbox.dir);
+    try {
+      await removeTaskSandbox(root, resolved, {
+        force: true,
+        deleteBranch: true,
+      });
+      ACTIVE_TASK_SANDBOXES.delete(resolved);
+    } catch {}
   }
 }
 
+async function cleanupTraceSandboxes(root: string, traceID: string) {
+  const targets = [...ACTIVE_TASK_SANDBOXES.entries()]
+    .filter(([, ownerTrace]) => ownerTrace === traceID)
+    .map(([dir]) => dir);
+  let removed = 0;
+  for (const dir of targets) {
+    try {
+      await removeTaskSandbox(root, dir, { force: true, deleteBranch: true });
+      ACTIVE_TASK_SANDBOXES.delete(dir);
+      removed += 1;
+    } catch {}
+  }
+  return removed;
+}
+
 async function executeStructuredPlan(input: {
   plan: any;
   root: string;
   inheritedModel?: string;
   inheritedThinking?: string;
   maxAttempts: number;
+  rootPolicy?: any;
   durableSlug?: string;
   traceID?: string;
   signal?: AbortSignal;
@@ -1789,6 +2106,7 @@ async function executeStructuredPlan(input: {
   for (let waveIndex = 0; waveIndex < safe.waves.length; waveIndex++) {
     const ids = safe.waves[waveIndex];
     let lastWaveFailure = "";
+    const failureByTask = new Map<string, string>();
 
     for (let attempt = 1; attempt <= input.maxAttempts; attempt++) {
       const prepared: Array<{
@@ -1807,12 +2125,13 @@ async function executeStructuredPlan(input: {
           let cwd = input.root;
           let sandbox: any = undefined;
 
-          if (gitCapable) {
+          if (gitCapable && writeFiles.length > 0) {
             const slug = "runtime-" + randomUUID().slice(0, 8) + "-w" + waveIndex + "-a" + attempt;
             sandbox = await createTaskSandbox(input.root, slug, id, {
               inheritDirtyRoot: true,
             });
             cwd = sandbox.dir;
+            ACTIVE_TASK_SANDBOXES.set(path.resolve(sandbox.dir), String(input.traceID || "structured"));
           }
 
           prepared.push({ task, cwd, sandbox, writeFiles });
@@ -1830,22 +2149,37 @@ async function executeStructuredPlan(input: {
         }
 
         let completed = 0;
+        const writerCount = prepared.filter((item) => item.writeFiles.length > 0).length;
+        const waveConcurrency = !gitCapable
+          ? 1
+          : writerCount > 0
+            ? Math.min(MAX_CONCURRENCY, MAX_WRITER_CONCURRENCY)
+            : MAX_CONCURRENCY;
         const waveResults = await mapLimit(
           prepared,
-          gitCapable ? MAX_CONCURRENCY : 1,
+          waveConcurrency,
           async (item) => {
             const taskText = [
               "Execute exactly this structured plan task.",
               "Do not broaden file scope. If the declared write file list is empty, do not edit files.",
+              "Start with the declared files/interfaces and supplied context. Do not inventory the repository. Use targeted symbol/path search only for a concrete unresolved acceptance or dependency gap; once the safe edit is understood, implement and verify instead of continuing discovery.",
               "",
               JSON.stringify(item.task, null, 2),
               "",
-              "Overall goal:",
-              String(input.plan.goal || ""),
-              lastWaveFailure
-                ? "\nFresh failure evidence from the previous wave attempt:\n" + cap(lastWaveFailure, 7000)
-                : "",
+              "Parent goal (context only; never broaden this leaf task):",
+              cap(String(input.plan.goal || ""), 700),
+              input.rootPolicy?.executionContractPrompt || "",
             ].filter(Boolean).join("\n");
+            const leafPolicy = leafTaskPolicy(item.task, input.rootPolicy || {});
+            const taskFailure = failureByTask.get(String(item.task.id)) || "";
+            const leafVisualRequired = visualEvidenceNeeded(taskText);
+            const leafFastDecision = turboFastPathDecision(leafPolicy, {
+              role: "executor",
+              attempt,
+              browserRequested: browserEvidenceNeeded(taskText, "executor"),
+              visualRequired: leafVisualRequired,
+            });
+            const leafAttemptStartedAt = Date.now();
 
             const plannedExecution: any = dynamicTaskByID.get(item.task.id);
             const deterministicReadOnly =
@@ -1978,8 +2312,8 @@ async function executeStructuredPlan(input: {
                   "",
                   "Overall goal:",
                   String(input.plan.goal || ""),
-                  lastWaveFailure
-                    ? "\nFresh failure evidence from the previous wave attempt:\n" + cap(lastWaveFailure, 7000)
+                  taskFailure
+                    ? "\nFresh task-local failure delta from the previous attempt:\n" + cap(taskFailure, 4200)
                     : "",
                 ].filter(Boolean).join("\n"),
                 item.cwd,
@@ -1990,6 +2324,8 @@ async function executeStructuredPlan(input: {
                 input.signal,
                 undefined,
                 input.traceID,
+                leafPolicy,
+                input.root,
               );
               results.push({
                 wave: waveIndex,
@@ -2027,8 +2363,8 @@ async function executeStructuredPlan(input: {
               };
             }
 
-            let focusedFailure = lastWaveFailure;
-            if (attempt > 1 && runtimeFailureNeedsDiagnosis(lastWaveFailure)) {
+            let focusedFailure = taskFailure;
+            if (attempt > 1 && runtimeFailureNeedsDiagnosis(taskFailure)) {
               const diagnosis = await runRoutedAgent(
                 "ues-debugger",
                 [
@@ -2038,16 +2374,18 @@ async function executeStructuredPlan(input: {
                   JSON.stringify(item.task, null, 2),
                   "",
                   "Previous runtime failure:",
-                  cap(lastWaveFailure, 7000),
+                  cap(taskFailure, 4200),
                 ].join("\n"),
                 item.cwd,
                 input.inheritedModel,
                 input.inheritedThinking,
                 attempt,
-                lastWaveFailure,
+                taskFailure,
                 input.signal,
                 undefined,
                 input.traceID,
+                leafPolicy,
+                input.root,
               );
               results.push({
                 wave: waveIndex,
@@ -2070,16 +2408,15 @@ async function executeStructuredPlan(input: {
               }
             }
 
+            const retryDelta = failureDelta(focusedFailure || taskFailure);
             const implementation = await runRoutedAgent(
               "ues-executor",
-              taskText + (focusedFailure && focusedFailure !== lastWaveFailure
-                ? "\n\nFocused diagnosis before retry:\n" + cap(focusedFailure, 7000)
-                : ""),
+              taskText,
               item.cwd,
               input.inheritedModel,
               input.inheritedThinking,
               attempt,
-              lastWaveFailure || undefined,
+              retryDelta || undefined,
               input.signal,
               (progress) => {
                 input.onUpdate?.({
@@ -2093,8 +2430,10 @@ async function executeStructuredPlan(input: {
                 });
               },
               input.traceID,
+              leafPolicy,
+              input.root,
             );
-            results.push({ wave: waveIndex, attempt, task: item.task.id, phase: "execute", ...implementation });
+            results.push({ wave: waveIndex, attempt, task: item.task.id, phase: "execute", leafPolicy, ...implementation });
 
             if (implementation.exitCode !== 0 || implementation.stopReason === "error") {
               if (!isAbortedRun(implementation)) {
@@ -2114,7 +2453,75 @@ async function executeStructuredPlan(input: {
               };
             }
 
-            const verification = await runRoutedAgent(
+            let verification: RunResult;
+            let leafFastGate: any = null;
+            if (leafFastDecision.eligible) {
+              const snapshot = runtimeWorkspaceSnapshot(item.cwd);
+              const receipts = await listReusableVerification(item.cwd, {
+                limit: 12,
+                maxAgeMs: 10 * 60_000,
+                previewBytes: 2200,
+                ...(snapshot.cacheable === true && snapshot.fingerprint
+                  ? { workspaceFingerprint: snapshot.fingerprint }
+                  : {}),
+              }).catch(() => ({ results: [] }));
+              leafFastGate = evaluateFastVerificationGate({
+                policy: leafPolicy,
+                implementation,
+                receipts: receipts?.results || [],
+                attemptStartedAtMs: leafAttemptStartedAt,
+                visualRequired: leafVisualRequired,
+              });
+            }
+
+            if (leafFastGate?.passed === true) {
+              verification = {
+                agent: "ues-deterministic-verifier",
+                task: taskText,
+                cwd: item.cwd,
+                exitCode: 0,
+                output: [
+                  "Per-leaf Turbo verification reused fresh behavioral evidence captured after this leaf implementation.",
+                  ...leafFastGate.behavioralReceipts.map((entry: any) => "- " + entry.command),
+                  "",
+                  "UES_VERDICT: PASS",
+                ].join("\n"),
+                stderr: "",
+                verdict: "PASS",
+                durationMs: 0,
+                toolCalls: 0,
+                toolNames: [],
+                report: {
+                  schemaVersion: 1,
+                  valid: true,
+                  verdict: "PASS",
+                  sections: {
+                    "checks-run": leafFastGate.behavioralReceipts.map((entry: any) => entry.command).join("\n"),
+                    "acceptance-criteria-proven": "Fresh behavioral receipt(s) exist at the post-implementation workspace fingerprint.",
+                    "completion-evidence": "Deterministic per-leaf PASS after this implementation attempt.",
+                  },
+                },
+                optimizations: {
+                  perLeafTurbo: true,
+                  behavioralReceiptCount: leafFastGate.behavioralReceipts.length,
+                },
+              };
+              input.onUpdate?.({
+                content: [{
+                  type: "text",
+                  text: `UES Per-Leaf Turbo: ${item.task.id} reused ${leafFastGate.behavioralReceipts.length} fresh behavioral receipt(s); skipped verifier model turn`,
+                }],
+                details: {
+                  wave: waveIndex,
+                  attempt,
+                  task: item.task.id,
+                  phase: "leaf-turbo-verified",
+                  leafPolicy,
+                  leafFastGate,
+                },
+              });
+            } else {
+              verification = await runRoutedAgent(
               "ues-verifier",
               [
                 "Verify exactly this structured plan task in the current isolated worktree.",
@@ -2141,8 +2548,11 @@ async function executeStructuredPlan(input: {
                 });
               },
               input.traceID,
+              leafPolicy,
+              input.root,
             );
-            results.push({ wave: waveIndex, attempt, task: item.task.id, phase: "verify", ...verification });
+            }
+            results.push({ wave: waveIndex, attempt, task: item.task.id, phase: "verify", leafPolicy, leafFastGate, ...verification });
             const passed = verification.exitCode === 0 && verification.verdict === "PASS";
             if (!isAbortedRun(verification)) {
               await recordRuntimeOutcome(implementation, taskText, passed, attempt - 1);
@@ -2188,8 +2598,12 @@ async function executeStructuredPlan(input: {
 
         const failed = waveResults.filter((item) => !item.passed);
         if (failed.length) {
+          for (const row of failed) {
+            const rawFailure = row.verification?.output || row.implementation?.output || "unknown failure";
+            failureByTask.set(String(row.item?.task?.id || "unknown"), failureDelta(rawFailure));
+          }
           lastWaveFailure = failed
-            .map((item) => item.verification?.output || item.implementation?.output || "unknown failure")
+            .map((item) => failureByTask.get(String(item.item?.task?.id || "unknown")) || "unknown failure")
             .join("\n\n---\n\n");
           await failDurablePrepared(prepared, lastWaveFailure);
           await cleanupSandboxes(input.root, prepared);
@@ -2207,9 +2621,9 @@ async function executeStructuredPlan(input: {
           };
         }
 
-        if (!gitCapable) {
-          // Without Git worktrees the safe graph is still serialized. Verification above
-          // is the evidence gate; changes already exist in the root working directory.
+        if (!gitCapable || prepared.every((item) => !item.sandbox?.dir)) {
+          // Read-only waves do not need a duplicate Git worktree. Their fresh
+          // verifier evidence is enough as long as the workspace stays unchanged.
           await completeDurableWave(waveResults);
           break;
         }
@@ -2217,13 +2631,21 @@ async function executeStructuredPlan(input: {
         const actualByTask = new Map<string, string[]>();
         let scopeFailure = "";
         for (const item of prepared) {
+          if (!item.sandbox?.dir) {
+            actualByTask.set(item.task.id, []);
+            continue;
+          }
           const changed = await sandboxChangedFiles(item.sandbox.dir, item.sandbox.integrationBase, input.signal);
           actualByTask.set(item.task.id, changed);
           const allowed = new Set(item.writeFiles);
           const unexpected = changed.filter((file) => !allowed.has(file));
           if (unexpected.length) {
-            scopeFailure +=
-              `${item.task.id}: changed files outside declared write scope: ${unexpected.join(", ")}\n`;
+            const scopeMessage =
+              `${item.task.id}: changed real source files outside declared write scope: ${unexpected.join(", ")}. ` +
+              "On retry, revert or avoid these files and satisfy the task strictly within its declared write scope. " +
+              "Do not silently broaden scope.";
+            failureByTask.set(String(item.task.id), failureDelta(scopeMessage, { maxChars: 2200 }));
+            scopeFailure += scopeMessage + "\n";
           }
         }
 
@@ -2232,7 +2654,12 @@ async function executeStructuredPlan(input: {
           for (const file of changed) {
             const previous = changedOwners.get(file);
             if (previous && previous !== taskID) {
-              scopeFailure += `wave conflict: ${previous} and ${taskID} both changed ${file}\n`;
+              const conflictMessage = `wave conflict: ${previous} and ${taskID} both changed real source file ${file}`;
+              const previousFailure = failureByTask.get(previous) || "";
+              const currentFailure = failureByTask.get(taskID) || "";
+              failureByTask.set(previous, failureDelta([previousFailure, conflictMessage].filter(Boolean).join("\n"), { maxChars: 2200 }));
+              failureByTask.set(taskID, failureDelta([currentFailure, conflictMessage].filter(Boolean).join("\n"), { maxChars: 2200 }));
+              scopeFailure += conflictMessage + "\n";
             } else {
               changedOwners.set(file, taskID);
             }
@@ -2260,6 +2687,7 @@ async function executeStructuredPlan(input: {
         const integrated: Array<{ item: any; receipt: any }> = [];
         try {
           for (const item of prepared) {
+            if (!item.sandbox?.dir) continue;
             const receipt = await integrateTaskSandbox(input.root, item.sandbox.dir, { keep: true });
             integrated.push({ item, receipt });
             integrations.push({ wave: waveIndex, task: item.task.id, ...receipt });
@@ -2379,7 +2807,52 @@ export default function (pi: ExtensionAPI) {
   // controller inside specialist workers.
   if (process.env.UES_CHILD_PROCESS === "1") return;
 
+  let directControllerAbort: AbortController | null = null;
+  let promptUesActive = false;
+  let directControllerRunner: ((task: string, ctx: any, admission: "command" | "automatic", admissionDecision?: any) => Promise<void>) | null = null;
+  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"]);
+  let normalActiveTools: string[] | null = null;
+
+  const currentNonUesTools = () =>
+    pi.getActiveTools().filter((name) => !UES_PARENT_TOOL_NAMES.has(String(name)));
+
+  const deactivateParentUesTools = () => {
+    const normal = currentNonUesTools();
+    normalActiveTools = normal;
+    try { pi.setActiveTools(normal); } catch {}
+  };
+
+  const activateParentUesTools = () => {
+    const normal = normalActiveTools || currentNonUesTools();
+    const registered = new Set(
+      (typeof (pi as any).getAllTools === "function" ? (pi as any).getAllTools() : [])
+        .map((tool: any) => String(tool?.name || "")),
+    );
+    const uesTools = [...UES_PARENT_TOOL_NAMES].filter((name) => registered.has(name));
+    try { pi.setActiveTools([...new Set([...normal, ...uesTools])]); } catch {}
+  };
+
+  const uesModeActive = () =>
+    promptUesActive || Boolean(directControllerAbort && !directControllerAbort.signal.aborted);
+
+  const syncSessionIdentity = (name: string, ctx: any) => {
+    if (!name) return;
+    try { pi.setSessionName(name); } catch {}
+    try { ctx?.ui?.setTitle?.(name); } catch {}
+  };
+
+  pi.on("session_start", async () => {
+    deactivateParentUesTools();
+  });
+
   pi.on("session_shutdown", async () => {
+    directControllerAbort?.abort();
+    directControllerAbort = null;
+    promptUesActive = false;
+    normalActiveTools = null;
     CONTEXT_PACK_CACHE.clear();
     clearSkillCompilerCache();
     clearAffectedTestCache();
@@ -2387,29 +2860,44 @@ export default function (pi: ExtensionAPI) {
     clearSemanticIndexRuntimeCache();
     MCP_HEALTH.clear();
     abortActiveCliChildren();
+    await stopAllServices().catch(() => []);
     await RPC_POOL.stopAll().catch(() => {});
+    for (const dir of [...ACTIVE_TASK_SANDBOXES.keys()]) {
+      const ownerRoot = await taskSandboxOwnerRoot(dir).catch(() => null);
+      if (!ownerRoot) continue;
+      await removeTaskSandbox(ownerRoot, dir, { force: true, deleteBranch: true }).catch(() => {});
+      ACTIVE_TASK_SANDBOXES.delete(dir);
+    }
   });
 
   pi.on("input", async (event, ctx) => {
     if (process.env.UES_CHILD_PROCESS === "1") return { action: "continue" };
-    if (
-      event.source !== "interactive" ||
-      !["steer", "followUp"].includes(String(event.streamingBehavior || ""))
-    ) {
-      return { action: "continue" };
-    }
+    if (event.source !== "interactive") return { action: "continue" };
 
     const text = String(event.text || "").trim();
     if (!text) return { action: "continue" };
 
+    const sessionName = sessionNameFromUesInput(text, ctx.cwd || "");
+    if (sessionName) syncSessionIdentity(sessionName, ctx);
+    if (/^\/ues-(?:resume|fix|feature|debug|review|audit|plan|research|critique|verify)(?:\s|$)/i.test(text)) {
+      promptUesActive = true;
+      activateParentUesTools();
+    }
+
     if (/^(?:stop|cancel|abort|dừng|dung|hủy|huy)(?:\s|$)/i.test(text)) {
+      if (!uesModeActive()) return { action: "continue" };
+      let directAborted = 0;
+      if (directControllerAbort && !directControllerAbort.signal.aborted) {
+        directControllerAbort.abort();
+        directAborted = 1;
+      }
       const result = await RPC_POOL.abortActive();
       const cliAborted = abortActiveCliChildren();
-      const total = result.aborted + cliAborted;
+      const total = directAborted + result.aborted + cliAborted;
       if (total > 0) {
         try {
           ctx.ui.notify(
-            `UES: aborted ${total} active child worker(s)` +
+            `UES: aborted ${total} active controller/child worker(s)` +
               (cliAborted ? ` (${cliAborted} CLI fallback)` : ""),
             "warning",
           );
@@ -2419,6 +2907,65 @@ export default function (pi: ExtensionAPI) {
       return { action: "continue" };
     }
 
+    if (!["steer", "followUp"].includes(String(event.streamingBehavior || ""))) {
+      if (directControllerAbort && !directControllerAbort.signal.aborted) {
+        const continuation = automaticUesContinuation(text, { activeRun: true });
+        if (continuation.forward) {
+          const forwarded = await RPC_POOL.steerActive(text).catch(() => ({
+            accepted: false,
+            reason: "steer-failed",
+            active: 0,
+          }));
+          if (forwarded.accepted) {
+            try { ctx.ui.notify("UES: natural continuation forwarded to the active child", "info"); } catch {}
+            return { action: "handled" };
+          }
+          try {
+            ctx.ui.notify(
+              "UES is already running; continuation could not be targeted safely, so the prompt was not swallowed.",
+              "warning",
+            );
+          } catch {}
+        }
+        return { action: "continue" };
+      }
+
+      if (
+        AUTO_ADMISSION_ENABLED &&
+        directControllerRunner &&
+        !(Array.isArray((event as any).images) && (event as any).images.length > 0)
+      ) {
+        const preliminaryAdmission = automaticUesAdmission(text);
+        const workspaceRoot = preliminaryAdmission.admit === true
+          ? resolveGitWorkspaceRoot(ctx.cwd || "")
+          : null;
+        const admission = workspaceRoot
+          ? automaticUesAdmission(text, { inGitWorkspace: true })
+          : preliminaryAdmission;
+        if (workspaceRoot && admission.admit === true) {
+          try {
+            ctx.ui.notify(
+              "UES " + PACKAGE_VERSION + ": " +
+                (admission.route === "guarded" ? "high-risk engineering task admitted" : "engineering task auto-admitted") +
+                " (" + admission.reason + ", confidence " + admission.confidence + ")",
+              admission.route === "guarded" ? "warning" : "info",
+            );
+          } catch {}
+          void directControllerRunner(text, ctx, "automatic", admission).catch((error) => {
+            try {
+              ctx.ui.notify(
+                "UES automatic controller failed to start: " +
+                  (error instanceof Error ? error.message : String(error)),
+                "error",
+              );
+            } catch {}
+          });
+          return { action: "handled" };
+        }
+      }
+      return { action: "continue" };
+    }
+
     const steered = await RPC_POOL.steerActive(text).catch(() => ({
       accepted: false,
       reason: "steer-failed",
@@ -2434,8 +2981,27 @@ export default function (pi: ExtensionAPI) {
     return { action: "continue" };
   });
 
+  pi.on("before_agent_start", async () => {
+    if (uesModeActive()) activateParentUesTools();
+    else deactivateParentUesTools();
+  });
+
+  pi.on("agent_end", async () => {
+    promptUesActive = false;
+    deactivateParentUesTools();
+  });
+
   pi.on("tool_call", async (event, ctx) => {
     const toolName = String(event.toolName || "");
+    if (!uesModeActive()) {
+      if (toolName.startsWith("ues_")) {
+        return {
+          block: true,
+          reason: "UES parent tools are hidden outside admitted UES runs. Submit a normal engineering task or start an explicit /ues-* command.",
+        };
+      }
+      return undefined;
+    }
     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);
@@ -2449,6 +3015,14 @@ export default function (pi: ExtensionAPI) {
     }
 
     const command = String((event.input as any)?.command || "");
+    if (looksLikeLongRunningServiceCommand(command)) {
+      return {
+        block: true,
+        reason:
+          "UES detected a likely long-running foreground service command. " +
+          "Use ues_service start/wait-ready/logs/stop so Pi can continue without blocking on the server process.",
+      };
+    }
     const risk = destructiveShellRisk(command);
     if (!risk.risky) return undefined;
     const allowed = await approveRisk(ctx, command, risk.id || "destructive");
@@ -2457,6 +3031,7 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.on("tool_result", async (event) => {
+    if (!uesModeActive()) return undefined;
     const toolName = String((event as any).toolName || "");
     if (!toolName || toolName === "bash" || toolName === "powershell") return undefined;
     MCP_HEALTH.finish(
@@ -2479,7 +3054,7 @@ export default function (pi: ExtensionAPI) {
       cwd: Type.Optional(Type.String({ description: "Working directory; defaults to the current Pi cwd" })),
     }),
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      const cwd = path.resolve(params.cwd || ctx.cwd);
+      const cwd = requireGitWorkspaceRoot(params.cwd || ctx.cwd, "ues_cli");
       const separator = params.args.indexOf("--");
       if (separator >= 0 && separator < params.args.length - 1) {
         const command = params.args.slice(separator + 1).join(" ");
@@ -2538,6 +3113,91 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.registerTool({
+    name: "ues_service",
+    label: "UES Managed Service",
+    description:
+      "Start and manage long-running dev servers/watchers without blocking Pi. Uses shell-free execution, bounded logs, readiness probes, evidence snapshots, and session cleanup. For start/restart, command is the executable only (for example node or npm); put every argument in args.",
+    parameters: Type.Object({
+      action: Type.Union([
+        Type.Literal("start"),
+        Type.Literal("wait-ready"),
+        Type.Literal("status"),
+        Type.Literal("logs"),
+        Type.Literal("stop"),
+        Type.Literal("restart"),
+      ]),
+      name: Type.String({ minLength: 1, maxLength: 64 }),
+      command: Type.Optional(Type.String({ minLength: 1 })),
+      args: Type.Optional(Type.Array(Type.String(), { maxItems: 128 })),
+      cwd: Type.Optional(Type.String()),
+      readyPort: Type.Optional(Type.Number({ minimum: 1, maximum: 65535 })),
+      readyHost: Type.Optional(Type.String({ maxLength: 255 })),
+      readyLog: Type.Optional(Type.String({ maxLength: 512 })),
+      timeoutMs: Type.Optional(Type.Number({ minimum: 100, maximum: 600000 })),
+      lifetimeMs: Type.Optional(Type.Number({ minimum: 10000, maximum: 7200000 })),
+      idleTimeoutMs: Type.Optional(Type.Number({ minimum: 5000, maximum: 3600000 })),
+      maxChars: Type.Optional(Type.Number({ minimum: 256, maximum: 128000 })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const hostCwd = path.resolve(ctx.cwd);
+        const serviceRoot = requireGitWorkspaceRoot(hostCwd, "ues_service");
+        const requestedServiceCwd = params.cwd
+          ? path.relative(serviceRoot, path.resolve(hostCwd, params.cwd)) || "."
+          : path.relative(serviceRoot, hostCwd) || ".";
+        let result: any;
+        if (params.action === "start") {
+          if (!params.command) throw new Error("ues_service start requires command");
+          const riskText = [params.command, ...(params.args || [])].join(" ");
+          const risk = destructiveShellRisk(riskText);
+          if (risk.risky) throw new Error(`UES service safety blocked ${risk.id || "destructive"} command`);
+          result = await startService(serviceRoot, {
+            name: params.name,
+            command: params.command,
+            args: params.args || [],
+            cwd: requestedServiceCwd,
+            readyPort: params.readyPort,
+            readyHost: params.readyHost,
+            readyLog: params.readyLog,
+            timeoutMs: params.timeoutMs,
+            lifetimeMs: params.lifetimeMs,
+            idleTimeoutMs: params.idleTimeoutMs,
+          });
+        } else if (params.action === "wait-ready") {
+          result = await waitForService(serviceRoot, params.name, { timeoutMs: params.timeoutMs });
+        } else if (params.action === "status") {
+          result = await serviceStatus(serviceRoot, params.name);
+        } else if (params.action === "logs") {
+          result = await serviceLogs(serviceRoot, params.name, { maxChars: params.maxChars, evidence: true });
+        } else if (params.action === "stop") {
+          result = await stopService(serviceRoot, params.name, { timeoutMs: params.timeoutMs });
+        } else if (params.action === "restart") {
+          result = await restartService(serviceRoot, params.name, {
+            timeoutMs: params.timeoutMs,
+            lifetimeMs: params.lifetimeMs,
+            idleTimeoutMs: params.idleTimeoutMs,
+          });
+        } else {
+          throw new Error("Unknown ues_service action");
+        }
+        const failed =
+          (params.action === "start" || params.action === "wait-ready") && result?.ready !== true;
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+          isError: failed,
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          details: { action: params.action, name: params.name },
+          isError: true,
+        };
+      }
+    },
+  });
+
+  const uesExecuteTool: any = {
     name: "ues_execute",
     label: "UES Execute",
     description:
@@ -2549,16 +3209,55 @@ export default function (pi: ExtensionAPI) {
     }),
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const hostBrowserTools = refreshHostBrowserToolNames(pi);
-      const cwd = path.resolve(params.cwd || ctx.cwd);
+      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 policy = classifyEngineeringTask(params.task);
-      const traceID = createTraceID("ues-execute");
+      const inheritedDirty = captureInheritedDirtyState(cwd);
+      const executionContract = buildExecutionContract(params.task, inheritedDirty);
+      const contractPrompt = executionContractPrompt(executionContract);
+      const suppliedPolicy = (params as any).__taskPolicy;
+      const basePolicy =
+        suppliedPolicy && typeof suppliedPolicy === "object"
+          ? suppliedPolicy
+          : classifyEngineeringTask(params.task);
+      const policy = {
+        ...basePolicy,
+        localEnvWriteExplicitlyAllowed: executionContract.localEnvWriteExplicitlyAllowed === true,
+        executionContractPrompt: contractPrompt,
+      };
+      const traceID = String((params as any).__traceID || createTraceID("ues-execute"));
+      const orphanCleanup = await pruneOrphanTaskSandboxes(cwd, {
+        minAgeMs: 5 * 60_000,
+        legacyMinAgeMs: 30 * 60_000,
+        ownedMinAgeMs: 60_000,
+        reclaimOwnerPid: process.pid,
+        protectedDirs: [...ACTIVE_TASK_SANDBOXES.keys()],
+      }).catch(() => ({ removed: [], skipped: [], sidecarsRemoved: [] }));
+      if (orphanCleanup.removed?.length) {
+        onUpdate?.({
+          content: [{ type: "text", text: `UES sandbox cleanup: removed ${orphanCleanup.removed.length} orphan worktree(s)` }],
+          details: { mode: "execute", phase: "sandbox-cleanup", orphanCleanup },
+        });
+      }
       await appendTrajectoryEvent(cwd, traceID, "controller.started", {
         profile: policy.executionProfile,
         risk: policy.risk,
         mode: policy.mode,
+        inheritedDirtyCount: executionContract.inheritedDirty?.paths?.length || 0,
+        explicitPhaseCount: executionContract.phases?.length || 0,
+        localEnvWriteExplicitlyAllowed: executionContract.localEnvWriteExplicitlyAllowed === true,
       }).catch(() => {});
+      if ((executionContract.inheritedDirty?.paths?.length || 0) > 0 || (executionContract.phases?.length || 0) > 0) {
+        onUpdate?.({
+          content: [{
+            type: "text",
+            text:
+              `UES contract: inherited dirty ${executionContract.inheritedDirty?.paths?.length || 0}; ` +
+              `explicit phases ${executionContract.phases?.length || 0}; local .env write ${executionContract.localEnvWriteExplicitlyAllowed ? "authorized" : "blocked"}`,
+          }],
+          details: { mode: "execute", phase: "execution-contract", executionContract, traceID },
+        });
+      }
       const browserLaneRequested =
         browserEvidenceNeeded(params.task, "executor") || visualEvidenceNeeded(params.task);
       if (browserLaneRequested) {
@@ -2603,9 +3302,16 @@ export default function (pi: ExtensionAPI) {
       });
 
       const run = async (agent: AgentName, task: string, attempt = 1, failure?: string) => {
+        const planningBudget = planningRuntimeBudget(roleForAgent(agent), attempt, {
+          executionProfile: policy.executionProfile,
+          risk: policy.risk,
+          taskChars: task.length,
+        });
+        let softSteerSent = false;
+        const governedTask = [task, "", contractPrompt].filter(Boolean).join("\n");
         const result = await runRoutedAgent(
           agent,
-          task,
+          governedTask,
           cwd,
           inheritedModel,
           inheritedThinking,
@@ -2613,6 +3319,30 @@ export default function (pi: ExtensionAPI) {
           failure,
           signal,
           (progress) => {
+            if (
+              !softSteerSent &&
+              (
+                (agent === "ues-architect" && shouldSoftSteerArchitect(progress, planningBudget)) ||
+                (agent === "ues-plan-checker" && shouldSoftSteerPlanningRole(progress, planningBudget))
+              )
+            ) {
+              softSteerSent = true;
+              const steerText =
+                agent === "ues-architect"
+                  ? "Stop repository exploration now. Use the evidence already gathered and emit the required UES_PLAN_JSON object immediately as the next substantive output. Do not start new broad searches or delay the JSON behind prose."
+                  : "Stop broad validation now. Check only unresolved declared paths and dependencies, then return the verdict immediately. End with exactly UES_VERDICT: PASS or UES_VERDICT: REVISE.";
+              void RPC_POOL.steerActive(steerText).catch(() => ({ accepted: false }));
+              onUpdate?.({
+                content: [{
+                  type: "text",
+                  text:
+                    agent === "ues-architect"
+                      ? "UES planning fast-stop: architect evidence budget reached; requesting immediate plan emission"
+                      : "UES planning fast-stop: plan-checker budget reached; requesting immediate verdict",
+                }],
+                details: { mode: "execute", phase: "planning-soft-steer", policy, progress, planningBudget, traceID },
+              });
+            }
             onUpdate?.({
               content: [{
                 type: "text",
@@ -2627,6 +3357,7 @@ export default function (pi: ExtensionAPI) {
             });
           },
           traceID,
+          policy,
         );
         steps.push(result);
         onUpdate?.({
@@ -2639,6 +3370,176 @@ export default function (pi: ExtensionAPI) {
         return result;
       };
 
+      if (policy.readOnly === true) {
+        const before = runtimeWorkspaceSnapshot(cwd);
+        const deterministicChecks = deterministicReadOnlyGitCommands(params.task);
+        let inspection: any;
+
+        if (deterministicChecks.length > 0) {
+          const rows: any[] = [];
+          for (const spec of deterministicChecks) {
+            const result = await runProcess(spec.command, spec.args, cwd, signal);
+            if (result.exitCode === 130 || result.stopReason === "aborted") {
+              const aborted: any = {
+                agent: "ues-deterministic-read-only",
+                task: params.task,
+                cwd,
+                exitCode: 130,
+                output: "Deterministic read-only command aborted: " + spec.label,
+                stderr: result.stderr || "",
+                verdict: null,
+                durationMs: result.durationMs || 0,
+                toolCalls: 0,
+                toolNames: [],
+                report: parseStructuredReport(""),
+                stopReason: "aborted",
+              };
+              steps.push(aborted);
+              return abortedResponse(aborted, "read-only-deterministic-check");
+            }
+            rows.push({
+              ...spec,
+              exitCode: result.exitCode,
+              stdout: cap(result.stdout || "", 8000),
+              stderr: cap(result.stderr || "", 4000),
+            });
+          }
+
+          const afterChecks = runtimeWorkspaceSnapshot(cwd);
+          const unchangedAfterChecks =
+            before.cacheable === true &&
+            afterChecks.cacheable === true &&
+            before.fingerprint === afterChecks.fingerprint;
+          const failedRows = rows.filter((row) => Number(row.exitCode) !== 0);
+          const deterministicPass = failedRows.length === 0 && unchangedAfterChecks;
+          const checksText = rows.map((row) => {
+            const payload = [row.stdout, row.stderr].filter(Boolean).join("\n").trim() || "(no output)";
+            return [
+              row.label + " — exit " + row.exitCode,
+              payload,
+            ].join("\n");
+          }).join("\n\n");
+          const failureText = [
+            ...failedRows.map((row) => row.label + " exited " + row.exitCode),
+            ...(unchangedAfterChecks ? [] : ["read-only workspace fingerprint changed"]),
+          ].join("\n") || "None.";
+
+          const output = [
+            "## Checks run",
+            checksText,
+            "",
+            "## Acceptance criteria proven",
+            deterministicPass
+              ? "All explicitly requested whitelisted Git inspection commands completed successfully."
+              : "The requested deterministic inspection did not fully pass.",
+            "",
+            "## Failures",
+            failureText,
+            "",
+            "## Unresolved gaps",
+            "None.",
+            "",
+            "## Checks not run",
+            "None.",
+            "",
+            "## Completion evidence",
+            "UES executed " + rows.length + " command-only read-only Git check(s) directly and compared the source workspace fingerprint before and after.",
+            "",
+            "UES_VERDICT: " + (deterministicPass ? "PASS" : "FAIL"),
+          ].join("\n");
+
+          inspection = {
+            agent: "ues-deterministic-read-only",
+            task: params.task,
+            cwd,
+            exitCode: deterministicPass ? 0 : 1,
+            output,
+            stderr: "",
+            verdict: deterministicPass ? "PASS" : "FAIL",
+            durationMs: 0,
+            toolCalls: rows.length,
+            toolNames: rows.map((row) => row.label),
+            report: parseStructuredReport(output),
+            optimizations: {
+              deterministicReadOnlyGit: true,
+              checkCount: rows.length,
+            },
+          };
+          steps.push(inspection);
+          onUpdate?.({
+            content: [{
+              type: "text",
+              text: "UES read-only fast path: executed " + rows.length + " whitelisted Git check(s) deterministically; skipped verifier model turn",
+            }],
+            details: { mode: "execute", phase: "read-only-deterministic", policy, traceID, checks: rows.map((row) => row.label) },
+          });
+        } else {
+          inspection = await run(
+            "ues-verifier",
+            [
+              "READ-ONLY INSPECTION MODE. Do not edit, create, delete, stage, commit, install dependencies, or start persistent services.",
+              "Use only the narrowest read-only commands and source inspection needed to answer the request.",
+              "Fresh command output is valid completion evidence for an inspection task; do not require behavioral tests when the user did not request a code change.",
+              "Return exactly these H2 sections: ## Checks run, ## Acceptance criteria proven, ## Failures, ## Unresolved gaps, ## Checks not run, ## Completion evidence.",
+              "Write exactly None in Failures and Unresolved gaps when there is no real requested failure or gap.",
+              "End with exactly UES_VERDICT: PASS or UES_VERDICT: FAIL.",
+              "Explicitly verify that source-facing workspace state is unchanged before returning PASS.",
+              "",
+              "Inspection request:",
+              params.task,
+            ].join("\n"),
+            1,
+          );
+          if (isAbortedRun(inspection)) return abortedResponse(inspection, "read-only-inspection");
+        }
+
+        const after = runtimeWorkspaceSnapshot(cwd);
+        const unchanged =
+          before.cacheable === true &&
+          after.cacheable === true &&
+          before.fingerprint === after.fingerprint;
+        const completionAudit = auditCompletion({
+          verification: inspection,
+          requireIntegration: false,
+          requireVisual: false,
+          workspaceSnapshot: after,
+          behavioralReceipts: [],
+          requireBehavioralReceipt: false,
+        });
+        if (!unchanged) {
+          completionAudit.passed = false;
+          completionAudit.failures = [...new Set([
+            ...(completionAudit.failures || []),
+            "read-only-workspace-mutated",
+          ])];
+        }
+
+        if (!completionAudit.passed) {
+          return {
+            content: [{
+              type: "text",
+              text: "UES read-only inspection did not pass: " + completionAudit.failures.join(", ") +
+                "\n\n" + inspection.output,
+            }],
+            details: { mode: "execute", policy, steps, completionAudit, traceID },
+            isError: true,
+          };
+        }
+
+        return {
+          content: [{
+            type: "text",
+            text: [
+              "UES read-only inspection PASS.",
+              "Workspace source fingerprint remained unchanged.",
+              "",
+              inspection.output,
+            ].join("\n"),
+          }],
+          details: { mode: "execute", policy, steps, completionAudit, traceID },
+        };
+      }
+
       if (shouldRunDedicatedDiagnosis(policy, 1)) {
         const diagnosis = await run("ues-debugger", params.task, 1);
         if (isAbortedRun(diagnosis)) return abortedResponse(diagnosis, "diagnosis");
@@ -2657,9 +3558,14 @@ export default function (pi: ExtensionAPI) {
           params.task,
           "",
           "Produce an implementation plan grounded in the current repository. Include exact files/interfaces, dependencies, risk controls, rollback notes, acceptance criteria and verification commands.",
-          "For deterministic scheduling, end with UES_PLAN_JSON: followed by one valid JSON object with schemaVersion=1, goal, and tasks.",
+          "For deterministic scheduling, emit UES_PLAN_JSON: followed by one valid JSON object with schemaVersion=1, goal, and tasks as the first substantive output. Do not delay the JSON behind long prose.",
           "Each task must have id, title, summary, dependsOn, files ({create,modify,test,delete,read}), acceptance, verification, and risk.",
+          executionContract.phases?.length
+            ? "PHASE CONTRACT: every execution task must include an integer phase matching one explicit execution PHASE number from the user request. Constraint/guardrail-only phases are invariants, not fake tasks. Do not omit, merge away, or invent execution phases. UES will add deterministic previous-phase barriers after validation."
+            : "",
+          "STRICT JSON CONTRACT: acceptance and verification are non-empty arrays of strings. risk is exactly one of low|medium|high|critical. Put descriptive risk prose in riskNotes. verificationCommands is optional and does not replace verification.",
           "Declare every file a task may write. Do not invent files: inspect the repository first.",
+          "DEEP efficiency rule: use the supplied runtime context/ranked references first; do not inventory the whole repository or re-read unchanged files. You have a bounded planning budget: prefer at most one targeted lookup per unresolved boundary, then emit the plan. Stop exploration once exact task scope, dependencies, acceptance, verification, and risk/rollback are grounded.",
         ].join("\n");
 
         let architect = await run(
@@ -2669,70 +3575,237 @@ export default function (pi: ExtensionAPI) {
           recentFailure || undefined,
         );
         if (isAbortedRun(architect)) return abortedResponse(architect, "planning");
-        if (architect.exitCode !== 0 || architect.stopReason === "error") {
-          return {
-            content: [{ type: "text", text: `Architecture pass failed:\n\n${architect.output}` }],
-            details: { mode: "execute", policy, steps },
-            isError: true,
-          };
-        }
 
-        structuredPlan = extractMarkedJson(architect.output, "UES_PLAN_JSON:");
-        let structuredValidation = structuredPlan ? validatePlan(structuredPlan) : null;
+        let planCandidate = extractValidatedPlan(architect.output);
+        structuredPlan = planCandidate.plan;
+        let structuredValidation = planCandidate.validation;
 
-        if (
-          (policy.mode === "long-horizon" || policy.profile?.durableState === true) &&
-          (!structuredPlan || structuredValidation?.valid !== true)
-        ) {
-          const repairEvidence = [
-            "The first architecture pass did not produce a valid UES_PLAN_JSON plan.",
-            structuredValidation ? JSON.stringify(structuredValidation, null, 2) : "UES_PLAN_JSON marker or JSON object was missing.",
-            "Return a corrected repository-grounded plan with the required marker and schema.",
-          ].join("\n");
-          architect = await run("ues-architect", planInstruction, 2, repairEvidence);
-          if (isAbortedRun(architect)) return abortedResponse(architect, "plan-repair");
-          structuredPlan = extractMarkedJson(architect.output, "UES_PLAN_JSON:");
-          structuredValidation = structuredPlan ? validatePlan(structuredPlan) : null;
-          if (
-            architect.exitCode !== 0 ||
-            architect.stopReason === "error" ||
-            !structuredPlan ||
-            structuredValidation?.valid !== true
-          ) {
-            return {
+        if (planCandidate.salvaged && structuredValidation?.valid === true) {
+          onUpdate?.({
+            content: [{
+              type: "text",
+              text: `UES planning salvage: recovered a valid plan from ${planCandidate.source} architect output`,
+            }],
+            details: {
+              mode: "execute",
+              phase: "planning-salvage",
+              source: planCandidate.source,
+              traceID,
+            },
+          });
+        }
+
+        const firstPlanValid =
+          structuredPlan &&
+          structuredValidation?.valid === true;
+
+        if (!firstPlanValid) {
+          const recoveryEvidence = failureDelta([
+            architect.exitCode !== 0 || architect.stopReason
+              ? "Previous architect pass stopped before a valid plan: " + String(architect.stopReason || architect.exitCode)
+              : "Previous architect pass returned an invalid plan.",
+            structuredValidation
+              ? JSON.stringify(structuredValidation, null, 2)
+              : "UES_PLAN_JSON marker or valid JSON object was missing.",
+            "RECOVERY RULE: do not restart repository exploration. Reuse the existing context/evidence, perform at most one targeted lookup for any blocking gap, then return the corrected plan immediately.",
+            "acceptance and verification must be non-empty string arrays; risk must be low|medium|high|critical; descriptive prose belongs in riskNotes.",
+          ].join("\n"), { maxChars: 4200 });
+
+          architect = await run("ues-architect", planInstruction, 2, recoveryEvidence);
+          if (isAbortedRun(architect)) return abortedResponse(architect, "plan-recovery");
+          planCandidate = extractValidatedPlan(architect.output);
+          structuredPlan = planCandidate.plan;
+          structuredValidation = planCandidate.validation;
+          if (planCandidate.salvaged && structuredValidation?.valid === true) {
+            onUpdate?.({
               content: [{
                 type: "text",
-                text: "Long-horizon plan could not be converted into a valid deterministic task graph.\n\n" +
-                  (structuredValidation ? JSON.stringify(structuredValidation, null, 2) : architect.output),
+                text: `UES planning salvage: recovery produced a valid ${planCandidate.source} plan`,
               }],
-              details: { mode: "execute", policy, steps, structuredPlan, structuredValidation },
-              isError: true,
-            };
+              details: {
+                mode: "execute",
+                phase: "planning-salvage",
+                source: planCandidate.source,
+                traceID,
+              },
+            });
           }
         }
 
-        const planCheck = await run(
-          "ues-plan-checker",
-          [
-            "Validate the following inline plan against the current repository. If persistent SPEC/PLAN files do not exist yet, evaluate this inline plan directly instead of failing only because those files are absent.",
-            "",
-            "Original task:",
-            params.task,
-            "",
-            "Inline plan:",
-            structuredPlan ? JSON.stringify(structuredPlan, null, 2) : architect.output,
-          ].join("\n"),
-          1,
-        );
+        if (
+          !structuredPlan ||
+          structuredValidation?.valid !== true
+        ) {
+          return {
+            content: [{
+              type: "text",
+              text: "Long-horizon planning exhausted its bounded fast-planning recovery without a valid deterministic task graph.\n\n" +
+                (structuredValidation ? JSON.stringify(structuredValidation, null, 2) : architect.output),
+            }],
+            details: { mode: "execute", policy, steps, structuredPlan, structuredValidation },
+            isError: true,
+          };
+        }
+
+        let phaseGate = enforcePhaseGates(structuredPlan, executionContract);
+        if (phaseGate.valid !== true) {
+          const phaseRevisionEvidence = failureDelta([
+            "The deterministic explicit-phase gate rejected the plan.",
+            "Do not rescan the repository. Revise only phase assignment/coverage/dependencies.",
+            "Every execution task must include an integer phase. Every explicit execution PHASE must have at least one task. Constraint-only phases are invariants, not tasks.",
+            "Phase gate errors:",
+            phaseGate.errors.join("\n"),
+            "Current plan:",
+            JSON.stringify(structuredPlan, null, 2),
+          ].join("\n"), { maxChars: 6200 });
+          const phaseRevisedArchitect = await run(
+            "ues-architect",
+            planInstruction,
+            2,
+            phaseRevisionEvidence,
+          );
+          if (isAbortedRun(phaseRevisedArchitect)) {
+            return abortedResponse(phaseRevisedArchitect, "phase-plan-auto-revise");
+          }
+          const phaseRevisedCandidate = extractValidatedPlan(phaseRevisedArchitect.output);
+          if (phaseRevisedCandidate.plan && phaseRevisedCandidate.validation?.valid === true) {
+            const revisedPhaseGate = enforcePhaseGates(
+              phaseRevisedCandidate.plan,
+              executionContract,
+            );
+            if (revisedPhaseGate.valid === true) {
+              architect = phaseRevisedArchitect;
+              structuredPlan = revisedPhaseGate.plan;
+              structuredValidation = phaseRevisedCandidate.validation;
+              phaseGate = revisedPhaseGate;
+              onUpdate?.({
+                content: [{
+                  type: "text",
+                  text: "UES phase gate: auto-revised phase coverage/dependencies once and recovered a valid gated plan",
+                }],
+                details: { mode: "execute", phase: "phase-plan-auto-revise", phaseGate, traceID },
+              });
+            } else {
+              phaseGate = revisedPhaseGate;
+            }
+          }
+        }
+        if (phaseGate.valid !== true) {
+          return {
+            content: [{
+              type: "text",
+              text:
+                "Explicit phase contract gate did not pass after bounded auto-recovery. UES will not flatten or skip user-declared phases.\n\n" +
+                phaseGate.errors.join("\n"),
+            }],
+            details: { mode: "execute", policy, steps, structuredPlan, phaseGate, executionContract },
+            isError: true,
+          };
+        }
+        structuredPlan = phaseGate.plan;
+
+        const buildPlanCheckTask = () => [
+          "Validate the following inline plan against the current repository. If persistent SPEC/PLAN files do not exist yet, evaluate this inline plan directly instead of failing only because those files are absent.",
+          "Use declared files and dependencies first. Do not inventory the repository. Resolve only concrete grounding gaps, then return the verdict.",
+          "",
+          "Original task:",
+          params.task,
+          "",
+          "Inline plan:",
+          structuredPlan ? JSON.stringify(structuredPlan, null, 2) : architect.output,
+        ].join("\n");
+
+        let planCheckTask = buildPlanCheckTask();
+        let planCheck = await run("ues-plan-checker", planCheckTask, 1);
         if (isAbortedRun(planCheck)) return abortedResponse(planCheck, "plan-verification");
+
+        const planCheckTransportFailure =
+          planCheck.verdict !== "PASS" &&
+          planCheck.verdict !== "REVISE" &&
+          (
+            planCheck.exitCode !== 0 ||
+            /hard-timeout|idle-timeout|UES RPC hard-timeout|UES RPC idle-timeout/i.test(
+              String(planCheck.output || "") + "\n" +
+              String(planCheck.stderr || "") + "\n" +
+              String(planCheck.stopReason || ""),
+            )
+          );
+
+        if (planCheckTransportFailure) {
+          const planCheckRecoveryEvidence = failureDelta([
+            "Previous plan-checker runtime failure:",
+            String(planCheck.output || planCheck.stderr || planCheck.stopReason || "unknown"),
+            "Reuse warm context. Do not scan broadly. Check only unresolved declared paths/dependencies and return PASS or REVISE.",
+          ].join("\n"), { maxChars: 2600 });
+
+          planCheck = await run(
+            "ues-plan-checker",
+            planCheckTask,
+            2,
+            planCheckRecoveryEvidence,
+          );
+          if (isAbortedRun(planCheck)) return abortedResponse(planCheck, "plan-verification-recovery");
+        }
+
+        if (planCheck.verdict === "REVISE") {
+          const revisionEvidence = failureDelta([
+            "The independent plan-checker requested a bounded revision.",
+            "Do not restart broad repository exploration. Change only the rejected plan claims/scope.",
+            "Plan-checker feedback:",
+            String(planCheck.output || ""),
+            "Current plan:",
+            JSON.stringify(structuredPlan, null, 2),
+          ].join("\n"), { maxChars: 5200 });
+
+          const revisedArchitect = await run(
+            "ues-architect",
+            planInstruction,
+            2,
+            revisionEvidence,
+          );
+          if (isAbortedRun(revisedArchitect)) return abortedResponse(revisedArchitect, "plan-auto-revise");
+          const revisedCandidate = extractValidatedPlan(revisedArchitect.output);
+          if (revisedCandidate.plan && revisedCandidate.validation?.valid === true) {
+            architect = revisedArchitect;
+            structuredPlan = revisedCandidate.plan;
+            structuredValidation = revisedCandidate.validation;
+            planCheckTask = buildPlanCheckTask();
+            onUpdate?.({
+              content: [{ type: "text", text: "UES plan gate: auto-revised the rejected plan; re-checking once" }],
+              details: { mode: "execute", phase: "plan-auto-revise", policy, traceID },
+            });
+            planCheck = await run(
+              "ues-plan-checker",
+              planCheckTask,
+              2,
+              failureDelta(String(planCheck.output || ""), { maxChars: 2600 }),
+            );
+            if (isAbortedRun(planCheck)) return abortedResponse(planCheck, "plan-auto-revise-check");
+          }
+        }
+
+        const finalPhaseGate = enforcePhaseGates(structuredPlan, executionContract);
+        if (finalPhaseGate.valid !== true) {
+          return {
+            content: [{
+              type: "text",
+              text:
+                "Plan revision lost the deterministic explicit-phase contract. UES will not execute it.\n\n" +
+                finalPhaseGate.errors.join("\n"),
+            }],
+            details: { mode: "execute", policy, steps, structuredPlan, finalPhaseGate, executionContract },
+            isError: true,
+          };
+        }
+        structuredPlan = finalPhaseGate.plan;
+
         if (planCheck.exitCode !== 0 || planCheck.verdict !== "PASS") {
           return {
-            content: [{ type: "text", text: `Plan gate did not pass:\n\n${planCheck.output}` }],
+            content: [{ type: "text", text: `Plan gate did not pass after bounded auto-recovery:\n\n${planCheck.output}` }],
             details: { mode: "execute", policy, steps, structuredPlan },
             isError: true,
           };
         }
-
         const durableRequested =
           policy.mode === "long-horizon" || policy.profile?.durableState === true;
         if (durableRequested) {
@@ -2754,6 +3827,10 @@ export default function (pi: ExtensionAPI) {
               planCheck.output,
               signal,
             );
+            durableWork.executionArtifacts = await persistExecutionContractArtifacts(
+              durableWork.dir,
+              executionContract,
+            );
             onUpdate?.({
               content: [{
                 type: "text",
@@ -2787,6 +3864,7 @@ export default function (pi: ExtensionAPI) {
             inheritedModel,
             inheritedThinking,
             maxAttempts,
+            rootPolicy: policy,
             durableSlug: durableWork?.slug,
             traceID,
             signal,
@@ -2893,12 +3971,81 @@ export default function (pi: ExtensionAPI) {
             }
           }
 
+          const verdictMatrix = buildFinalVerdictMatrix(params.task, {
+            contract: executionContract,
+            primaryPass: true,
+            integrationPass: true,
+            primaryOutput: (scheduled.results || [])
+              .map((row: any) => row?.verification?.output || row?.implementation?.output || "")
+              .filter(Boolean)
+              .join("\n"),
+            integrationOutput: integration.output,
+            visualOutput: visualResult?.output || "",
+            primaryChecks: (scheduled.results || [])
+              .flatMap((row: any) => Object.values(row?.verification?.report?.sections || {}))
+              .filter(Boolean)
+              .join("\n"),
+            integrationChecks: integration.report?.sections?.["checks-run"] || "",
+            visualChecks: visualResult?.report?.sections?.["checks-run"] || "",
+          });
+
+          const finalEvidenceForContract = [
+            integration.output,
+            visualResult?.output || "",
+          ].filter(Boolean).join("\n\n--- VISUAL ---\n\n");
+
+          if (verdictMatrix.final !== "PASS") {
+            if (durableWork) {
+              await durableRecordIntegration(
+                cwd,
+                durableWork.slug,
+                "PARTIAL",
+                finalEvidenceForContract,
+                signal,
+              ).catch(() => {});
+              await finalizeExecutionContractArtifacts(
+                durableWork.dir,
+                executionContract,
+                verdictMatrix,
+                finalEvidenceForContract,
+              ).catch(() => null);
+            }
+            const deviceOnlyPending =
+              verdictMatrix.final === "SOURCE_RUNTIME_PASS_DEVICE_NOT_VERIFIED";
+            return {
+              content: [{
+                type: "text",
+                text: [
+                  deviceOnlyPending
+                    ? "UES source/runtime verification passed, but requested real-device verification is still pending."
+                    : "UES deterministic final gate is not fully verified.",
+                  "",
+                  verdictMatrix.source,
+                  verdictMatrix.runtime,
+                  verdictMatrix.dbClean,
+                  verdictMatrix.device,
+                  "",
+                  integration.output,
+                ].join("\n"),
+              }],
+              details: {
+                mode: "execute",
+                policy,
+                steps,
+                structuredPlan,
+                scheduled,
+                durableWork,
+                verdictMatrix,
+                executionContract,
+                traceID,
+              },
+              isError: !deviceOnlyPending,
+            };
+          }
+
           let durableFinalization: any = null;
           if (durableWork) {
-            const finalEvidence = [
-              integration.output,
-              visualResult?.output || "",
-            ].filter(Boolean).join("\n\n--- VISUAL ---\n\n");
+            const finalEvidence = finalEvidenceForContract;
             try {
               durableFinalization = await durableRecordIntegration(
                 cwd,
@@ -2921,6 +4068,15 @@ export default function (pi: ExtensionAPI) {
             }
           }
 
+          if (durableWork) {
+            await finalizeExecutionContractArtifacts(
+              durableWork.dir,
+              executionContract,
+              verdictMatrix,
+              finalEvidenceForContract,
+            ).catch(() => null);
+          }
+
           const memoryFiles = [...new Set(structuredPlan.tasks.flatMap((task: any) => taskWriteFiles(task)))];
           const memory = durableWork
             ? durableFinalization?.finalized?.memory || null
@@ -2932,6 +4088,10 @@ export default function (pi: ExtensionAPI) {
                 `UES scheduled execution PASS across ${structuredPlan.tasks.length} task(s).`,
                 `Safe waves: ${scheduled.schedule?.safeWaves?.length || 0}; integrations: ${scheduled.integrations?.length || 0}.`,
                 durableWork ? `Durable state: .ues-work/${durableWork.slug} finalized with fresh integration receipt.` : "",
+                verdictMatrix.source,
+                verdictMatrix.runtime,
+                verdictMatrix.dbClean,
+                verdictMatrix.device,
                 "",
                 integration.output,
               ].join("\n"),
@@ -2946,6 +4106,8 @@ export default function (pi: ExtensionAPI) {
               memory,
               durableWork,
               durableFinalization,
+              verdictMatrix,
+              executionContract,
               traceID,
             },
           };
@@ -2979,18 +4141,19 @@ export default function (pi: ExtensionAPI) {
           recentFailure = diagnosis.output;
         }
 
-        const fastBoundedLane =
-          policy.executionProfile === "fast" &&
-          policy.singleFileBounded === true &&
-          policy.risk === "low" &&
-          !visualEvidenceNeeded(params.task) &&
-          !browserEvidenceNeeded(params.task, "executor");
+        const fastDecision = turboFastPathDecision(policy, {
+          role: "executor",
+          attempt,
+          browserRequested: browserEvidenceNeeded(params.task, "executor"),
+          visualRequired: visualEvidenceNeeded(params.task),
+        });
+        const fastBoundedLane = fastDecision.eligible;
         const fastAttemptStartedAt = Date.now();
         const executorTask = [
           params.task,
           recentFailure ? "\nEvidence from diagnosis/previous failed verification:\n" + cap(recentFailure, 7000) : "",
           fastBoundedLane
-            ? "\nFAST bounded rule: stay on the named file, implement every explicit branch, and produce fresh behavioral evidence before handoff. Prefer one focused project-native test command. If no JS/TS test exists, use a temporary .ues-cache/fast-acceptance.test.mjs and run node --test .ues-cache/fast-acceptance.test.mjs so the controller can independently reuse the successful tool-boundary receipt. Cover every enumerated error, boundary, idempotency and non-mutation case; syntax/build alone is insufficient."
+            ? "\nFAST bounded rule: stay on the named target file. Read that file first; do not inventory the repository or run broad searches unless the target is missing or direct evidence proves wider scope. Make the smallest edit, then run one focused behavioral check and stop once a fresh PASS receipt covers every explicit branch. If no project-native JS/TS test exists, use one temporary .ues-cache/fast-acceptance.test.mjs probe, run node --test .ues-cache/fast-acceptance.test.mjs, and remove only that probe afterwards. Syntax/build alone is insufficient."
             : "",
           "\nImplement the smallest coherent change. Do not push, publish, deploy, rewrite history, or broaden scope without evidence.",
         ].filter(Boolean).join("\n");
@@ -3008,6 +4171,37 @@ export default function (pi: ExtensionAPI) {
           continue;
         }
 
+        const inheritedDirtyCheck = detectInheritedDirtyViolations(
+          cwd,
+          executionContract.inheritedDirty,
+          executionContract.approvedInheritedDirtyPaths || [],
+        );
+        if (!inheritedDirtyCheck.safe) {
+          await recordRuntimeOutcome(implementation, params.task, false, attempt - 1);
+          return {
+            content: [{
+              type: "text",
+              text: [
+                "UES inherited dirty-work guard stopped completion.",
+                "The implementation changed pre-existing dirty source work that was not explicitly authorized by the original task.",
+                "UES will not auto-restore or overwrite these files.",
+                "",
+                ...inheritedDirtyCheck.violations.map((item: any) => "- " + item.path),
+              ].join("\n"),
+            }],
+            details: {
+              mode: "execute",
+              policy,
+              steps,
+              attempts: attempt,
+              executionContract,
+              inheritedDirtyCheck,
+              traceID,
+            },
+            isError: true,
+          };
+        }
+
         let verification: RunResult;
         let fastGate: any = null;
         if (fastBoundedLane) {
@@ -3029,7 +4223,10 @@ export default function (pi: ExtensionAPI) {
             optimizations: { fastDeterministicVerification: true, behavioralReceiptCount: fastGate.behavioralReceipts.length },
           };
           steps.push(verification);
-          onUpdate?.({ content: [{ type: "text", text: "UES FAST verifier: reused " + fastGate.behavioralReceipts.length + " fresh behavioral receipt(s); skipped an extra verifier model turn" }], details: { mode: "execute", policy, fastGate, traceID } });
+          onUpdate?.({
+            content: [{ type: "text", text: "UES Turbo Fast Path: reused " + fastGate.behavioralReceipts.length + " fresh behavioral receipt(s); skipped verifier model turn" }],
+            details: { mode: "execute", phase: "turbo-fast-verified", policy, fastGate, fastDecision, traceID },
+          });
         } else {
           verification = await run(
             "ues-verifier",
@@ -3125,7 +4322,7 @@ export default function (pi: ExtensionAPI) {
           requireVisual: visualEvidenceNeeded(params.task),
           workspaceSnapshot: completionSnapshot,
           behavioralReceipts: freshReceipts,
-          requireBehavioralReceipt: true,
+          requireBehavioralReceipt: policy.requireBehavioralReceipt !== false,
         });
         if (!completionAudit.passed) {
           recentFailure = "Completion auditor rejected PASS: " + completionAudit.failures.join(", ");
@@ -3138,6 +4335,52 @@ export default function (pi: ExtensionAPI) {
           };
         }
 
+        const verdictMatrix = buildFinalVerdictMatrix(params.task, {
+          contract: executionContract,
+          primaryPass: true,
+          integrationPass: integrationResult ? true : undefined,
+          primaryOutput: verification.output,
+          integrationOutput: integrationResult?.output || "",
+          visualOutput: visualResult?.output || "",
+          primaryChecks: verification.report?.sections?.["checks-run"] || "",
+          integrationChecks: integrationResult?.report?.sections?.["checks-run"] || "",
+          visualChecks: visualResult?.report?.sections?.["checks-run"] || "",
+        });
+
+        if (verdictMatrix.final !== "PASS") {
+          await recordRuntimeOutcome(implementation, params.task, false, attempt - 1);
+          const deviceOnlyPending =
+            verdictMatrix.final === "SOURCE_RUNTIME_PASS_DEVICE_NOT_VERIFIED";
+          return {
+            content: [{
+              type: "text",
+              text: [
+                deviceOnlyPending
+                  ? "UES source/runtime verification passed, but requested real-device verification is still pending."
+                  : "UES deterministic final gate is not fully verified.",
+                "",
+                verdictMatrix.source,
+                verdictMatrix.runtime,
+                verdictMatrix.dbClean,
+                verdictMatrix.device,
+                "",
+                integrationResult?.output || verification.output,
+              ].join("\n"),
+            }],
+            details: {
+              mode: "execute",
+              policy,
+              steps,
+              attempts: attempt,
+              completionAudit,
+              verdictMatrix,
+              executionContract,
+              traceID,
+            },
+            isError: !deviceOnlyPending,
+          };
+        }
+
         await recordRuntimeOutcome(implementation, params.task, true, attempt - 1);
         const memory = await rememberVerifiedTask(cwd, params.task, verification, integrationResult);
         const final = steps.at(-1);
@@ -3147,11 +4390,15 @@ export default function (pi: ExtensionAPI) {
             text: [
               `UES execution PASS after ${attempt} attempt(s).`,
               `Policy: ${policy.executionProfile}/${policy.risk}; model tier: ${implementation.modelTier || "default"}.`,
+              verdictMatrix.source,
+              verdictMatrix.runtime,
+              verdictMatrix.dbClean,
+              verdictMatrix.device,
               "",
               final?.output || verification.output,
             ].join("\n"),
           }],
-          details: { mode: "execute", policy, steps, attempts: attempt, memory, completionAudit, traceID },
+          details: { mode: "execute", policy, steps, attempts: attempt, memory, completionAudit, verdictMatrix, executionContract, traceID },
         };
       }
 
@@ -3164,6 +4411,355 @@ export default function (pi: ExtensionAPI) {
         isError: true,
       };
     },
+  };
+  pi.registerTool(uesExecuteTool);
+
+  // Extension commands are resolved before prompt templates in Pi. Registering
+  // /ues-run here makes controller admission deterministic: weak models never
+  // have to remember to call ues_execute themselves.
+  pi.registerCommand("ues-status", {
+    description: "Show the loaded UES runtime version and current session policy basics",
+    handler: async (_args, ctx) => {
+      const status = [
+        "UES runtime: " + PACKAGE_VERSION,
+        "Package root: " + PACKAGE_ROOT,
+        "Child runtime: " + CHILD_RUNTIME,
+        "Adaptive context: " + (ADAPTIVE_CONTEXT_ENABLED ? "on" : "off"),
+        "Micro skills: " + (MICRO_SKILLS_ENABLED ? "on" : "off"),
+        "Turbo Fast Path: on",
+        "Parent UES tools hidden outside UES runs: on",
+        "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",
+        "Local .env mutation guard: on",
+        "Portable temp-path guard: on",
+        "Explicit phase barriers: on",
+        "Independent final verdict matrix: on",
+        "Disk hygiene: bounded + auto-clean",
+        "Writer concurrency: " + MAX_WRITER_CONCURRENCY,
+      ].join("\n");
+      pi.sendMessage({
+        customType: "ues-runtime-status",
+        content: status,
+        display: true,
+        details: { version: PACKAGE_VERSION, packageRoot: PACKAGE_ROOT, childRuntime: CHILD_RUNTIME },
+      }, { triggerTurn: false });
+      try { ctx.ui.notify("UES runtime " + PACKAGE_VERSION + " loaded", "info"); } catch {}
+    },
+  });
+
+  pi.registerCommand("ues-clean", {
+    description: "Safely remove stale UES task sandboxes and orphan metadata for the current repository",
+    handler: async (_args, ctx) => {
+      if (uesModeActive()) {
+        try { ctx.ui.notify("UES cleanup refused while a UES task is active", "warning"); } catch {}
+        return;
+      }
+      let workspaceRoot: string;
+      try {
+        workspaceRoot = requireGitWorkspaceRoot(ctx.cwd, "/ues-clean");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        pi.sendMessage({
+          customType: "ues-cleanup-result",
+          content: "UES cleanup refused unsafe workspace.\n" + message,
+          display: true,
+          details: { error: message },
+        }, { triggerTurn: false });
+        try { ctx.ui.notify(message, "error"); } catch {}
+        return;
+      }
+      const cleanup = await pruneOrphanTaskSandboxes(workspaceRoot, {
+        minAgeMs: 5 * 60_000,
+        legacyMinAgeMs: 30 * 60_000,
+        ownedMinAgeMs: 0,
+        reclaimOwnerPid: process.pid,
+        protectedDirs: [...ACTIVE_TASK_SANDBOXES.keys()],
+      }).catch((error) => ({
+        removed: [],
+        skipped: [],
+        sidecarsRemoved: [],
+        error: error instanceof Error ? error.message : String(error),
+      }));
+      const removed = Number(cleanup?.removed?.length || 0);
+      const sidecars = Number(cleanup?.sidecarsRemoved?.length || 0);
+      const skipped = Number(cleanup?.skipped?.length || 0);
+      await stopAllServices(workspaceRoot).catch(() => []);
+      const transientDirs = [".ues-traces", ".ues-services", ".ues-dashboard"];
+      const removedRuntimeDirs: string[] = [];
+      for (const name of transientDirs) {
+        const target = path.join(workspaceRoot, name);
+        if (!fs.existsSync(target)) continue;
+        await fs.promises.rm(target, { recursive: true, force: true }).catch(() => {});
+        if (!fs.existsSync(target)) removedRuntimeDirs.push(name);
+      }
+
+      const cacheDir = path.join(workspaceRoot, ".ues-cache");
+      const removedCacheEntries: string[] = [];
+      if (fs.existsSync(cacheDir)) {
+        const entries = await fs.promises.readdir(cacheDir, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+          if (entry.name === "evidence-v1") continue;
+          if (
+            entry.name === "semantic-index-v1.json" ||
+            entry.name.startsWith("semantic-index-v1.json.") ||
+            entry.name === "verification-broker-v1.json" ||
+            entry.name.startsWith("verification-broker-v1.json.")
+          ) {
+            await fs.promises.rm(path.join(cacheDir, entry.name), { recursive: true, force: true }).catch(() => {});
+            removedCacheEntries.push(entry.name);
+          }
+        }
+      }
+      const evidenceGc = await gcEvidenceStore(workspaceRoot, {
+        maxBytes: 96 * 1024 * 1024,
+        maxEntries: 600,
+        maxAgeDays: 14,
+      }).catch((error) => ({
+        removed: [],
+        removedCount: 0,
+        protectedEntries: 0,
+        protectedBytes: 0,
+        error: error instanceof Error ? error.message : String(error),
+      }));
+
+      if (fs.existsSync(cacheDir)) {
+        const remaining = await fs.promises.readdir(cacheDir).catch(() => ["unknown"]);
+        if (remaining.length === 0) await fs.promises.rm(cacheDir, { recursive: true, force: true }).catch(() => {});
+      }
+
+      const text = [
+        "UES cleanup complete.",
+        "Removed sandboxes: " + removed,
+        "Removed orphan metadata: " + sidecars,
+        "Removed transient runtime dirs: " + (removedRuntimeDirs.join(", ") || "none"),
+        "Removed rebuildable cache entries: " + (removedCacheEntries.length || 0),
+        "Pruned evidence blobs: " + Number(evidenceGc?.removedCount || 0),
+        "Protected verified-memory evidence: " + Number(evidenceGc?.protectedEntries || 0),
+        "Protected/recent entries kept: " + skipped,
+        "Preserved durable state: .ues-work, .ues-memory, .ues-learning, .ues-evals and verified-memory evidence",
+        cleanup?.baseRemoved ? "Sandbox base directory removed because it is empty." : "",
+        cleanup?.error ? "Error: " + cleanup.error : "",
+      ].filter(Boolean).join("\n");
+      pi.sendMessage({
+        customType: "ues-cleanup-result",
+        content: text,
+        display: true,
+        details: { ...cleanup, removedRuntimeDirs, removedCacheEntries, evidenceGc },
+      }, { triggerTurn: false });
+      try {
+        ctx.ui.notify(
+          "UES cleanup removed/pruned " +
+            (removed + sidecars + removedRuntimeDirs.length + removedCacheEntries.length + Number(evidenceGc?.removedCount || 0)) +
+            " stale/transient artifact(s)",
+          "info",
+        );
+      } catch {}
+    },
+  });
+
+  directControllerRunner = async (task, ctx, admission, admissionDecision) => {
+    if (directControllerAbort && !directControllerAbort.signal.aborted) {
+      try { ctx.ui.notify("UES controller is already running in this session", "warning"); } catch {}
+      return;
+    }
+
+    let workspaceRoot: string;
+    try {
+      workspaceRoot = requireGitWorkspaceRoot(ctx.cwd, admission === "automatic" ? "automatic UES admission" : "/ues-run");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      pi.sendMessage({
+        customType: "ues-controller-result",
+        content: message,
+        display: true,
+        details: { controllerUsed: false, controllerPass: false, reason: "unsafe-workspace-root" },
+      }, { triggerTurn: false });
+      try { ctx.ui.notify(message, "error"); } catch {}
+      return;
+    }
+
+    const abort = new AbortController();
+    directControllerAbort = abort;
+    const directTraceID = createTraceID(admission === "automatic" ? "ues-auto" : "ues-run");
+    syncSessionIdentity(uesSessionName("run", task, workspaceRoot), ctx);
+    let result: any;
+    let lastProgressNoticeAt = 0;
+    let lastProgressKey = "";
+    try {
+      const directPolicy =
+        admissionDecision?.policy && typeof admissionDecision.policy === "object"
+          ? admissionDecision.policy
+          : classifyEngineeringTask(task);
+      const routeLabel =
+        admission === "automatic"
+          ? admissionDecision?.route === "guarded"
+            ? "high-risk auto controller started ("
+            : "auto controller started ("
+          : "controller started (";
+      try {
+        ctx.ui.notify(
+          "UES " + PACKAGE_VERSION + ": " + routeLabel +
+            String(directPolicy.executionProfile || directPolicy.mode || "unknown") +
+            "/" + String(directPolicy.risk || "unknown") + ")",
+          admissionDecision?.route === "guarded" ? "warning" : "info",
+        );
+      } catch {}
+      result = await uesExecuteTool.execute(
+        `ues-run-${randomUUID()}`,
+        { task, cwd: workspaceRoot, __traceID: directTraceID, __taskPolicy: directPolicy },
+        abort.signal,
+        (update: any) => {
+          const text = (update?.content || [])
+            .filter((part: any) => part?.type === "text" && typeof part.text === "string")
+            .map((part: any) => part.text)
+            .join("\n")
+            .trim();
+          if (text) {
+            try { ctx.ui.setStatus("ues-run", cap(text, 180)); } catch {}
+          }
+
+          const progress = update?.details?.progress;
+          if (progress) {
+            const progressKey = String(progress.agent || "") + ":" + String(update?.details?.phase || "");
+            const now = Date.now();
+            const phaseChanged = progressKey && progressKey !== lastProgressKey;
+            const heartbeatDue = now - lastProgressNoticeAt >= 60_000;
+            if (phaseChanged || heartbeatDue) {
+              const message =
+                "UES: " + String(progress.agent || "worker") +
+                " running " + Math.round(Number(progress.elapsedMs || 0) / 1000) + "s" +
+                " (idle " + Math.round(Number(progress.idleMs || 0) / 1000) + "s, tools " +
+                Number(progress.toolCalls || 0) +
+                (progress.activeTool ? ", " + String(progress.activeTool) : "") + ")";
+              try {
+                ctx.ui.notify(
+                  message,
+                  Number(progress.idleMs || 0) >= 45_000 ? "warning" : "info",
+                );
+              } catch {}
+              lastProgressNoticeAt = now;
+              lastProgressKey = progressKey;
+            }
+          }
+
+          if (process.env.UES_EVAL_DIRECT_TELEMETRY === "1") {
+            process.stderr.write(JSON.stringify({
+              type: "ues_controller_progress",
+              phase: update?.details?.phase || null,
+              task: update?.details?.task || null,
+              agent: progress?.agent || null,
+              elapsedMs: Number(progress?.elapsedMs || 0),
+              idleMs: Number(progress?.idleMs || 0),
+              toolCalls: Number(progress?.toolCalls || 0),
+              activeTool: progress?.activeTool || null,
+              note: progress?.note || null,
+              text: text ? cap(text, 240) : null,
+            }) + "\n");
+          }
+        },
+        ctx,
+      );
+    } catch (error) {
+      result = {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        details: { mode: "execute", reason: "direct-controller-exception" },
+        isError: true,
+      };
+    } finally {
+      const traceRemoved = await cleanupTraceSandboxes(workspaceRoot, directTraceID).catch(() => 0);
+      const staleCleanup = await pruneOrphanTaskSandboxes(workspaceRoot, {
+        minAgeMs: 5 * 60_000,
+        legacyMinAgeMs: 30 * 60_000,
+        ownedMinAgeMs: 0,
+        reclaimOwnerPid: process.pid,
+        protectedDirs: [...ACTIVE_TASK_SANDBOXES.keys()],
+      }).catch(() => ({ removed: [], skipped: [], sidecarsRemoved: [] }));
+      const cleaned =
+        Number(traceRemoved || 0) +
+        Number(staleCleanup?.removed?.length || 0) +
+        Number(staleCleanup?.sidecarsRemoved?.length || 0);
+      if (cleaned > 0) {
+        try { ctx.ui.notify("UES cleanup: removed " + cleaned + " stale sandbox artifact(s)", "info"); } catch {}
+      }
+      if (directControllerAbort === abort) directControllerAbort = null;
+      try { ctx.ui.setStatus("ues-run", undefined); } catch {}
+    }
+
+    const content = (result?.content || [])
+      .filter((part: any) => part?.type === "text" && typeof part.text === "string")
+      .map((part: any) => part.text)
+      .join("\n")
+      .trim() || "(UES controller returned no text)";
+    const controllerPass = result?.isError !== true;
+
+    if (process.env.UES_EVAL_DIRECT_TELEMETRY === "1") {
+      const details = result?.details || null;
+      const telemetryDetails = details
+        ? {
+            mode: details.mode,
+            attempts: details.attempts,
+            policy: details.policy
+              ? {
+                  mode: details.policy.mode,
+                  executionProfile: details.policy.executionProfile,
+                  risk: details.policy.risk,
+                }
+              : null,
+            steps: Array.isArray(details.steps)
+              ? details.steps.map((step: any) => ({
+                  agent: step?.agent,
+                  exitCode: step?.exitCode,
+                  optimizations: step?.optimizations || null,
+                  usage: step?.usage || null,
+                  toolCalls: Number(step?.toolCalls || 0),
+                  toolNames: Array.isArray(step?.toolNames) ? step.toolNames : [],
+                }))
+              : [],
+          }
+        : null;
+      process.stderr.write(JSON.stringify({
+        type: "ues_controller_direct",
+        controllerUsed: true,
+        controllerPass,
+        details: telemetryDetails,
+      }) + "\n");
+    }
+
+    pi.sendMessage({
+      customType: "ues-controller-result",
+      content,
+      display: true,
+      details: {
+        controllerUsed: true,
+        controllerPass,
+        admission,
+        admissionRoute: admissionDecision?.route || (admission === "command" ? "command" : "auto"),
+        admissionConfidence: admissionDecision?.confidence || null,
+        admissionReason: admissionDecision?.reason || null,
+        ...(result?.details || {}),
+      },
+    });
+
+    try {
+      ctx.ui.notify(
+        controllerPass ? "UES " + PACKAGE_VERSION + ": verified controller run completed" : "UES " + PACKAGE_VERSION + ": controller run failed verification",
+        controllerPass ? "info" : "error",
+      );
+    } catch {}
+
+  };
+
+  pi.registerCommand("ues-run", {
+    description: "Run an engineering task directly through the deterministic UES controller",
+    handler: async (args, ctx) => {
+      const task = String(args || "").trim();
+      if (!task) {
+        try { ctx.ui.notify("Usage: /ues-run <engineering task>", "warning"); } catch {}
+        return;
+      }
+      await directControllerRunner?.(task, ctx, "command");
+    },
   });
 
   pi.registerTool({
@@ -3293,7 +4889,11 @@ export default function (pi: ExtensionAPI) {
       }
 
       let completed = 0;
-      const results = await mapLimit(tasks, MAX_CONCURRENCY, async (item) => {
+      const dispatchHasWriters = tasks.some((item) => WRITE_AGENTS.has(item.agent));
+      const dispatchConcurrency = dispatchHasWriters
+        ? Math.min(MAX_CONCURRENCY, MAX_WRITER_CONCURRENCY)
+        : MAX_CONCURRENCY;
+      const results = await mapLimit(tasks, dispatchConcurrency, async (item) => {
         const result = await runRoutedAgent(
           item.agent as AgentName,
           item.task,