@piagent/platform 1.6.1 → 1.8.0

package/packages/piagent-core/extensions/piagent-guard.ts

@@ -1,9 +1,11 @@
+import { observedFocusedTestSummary, retainFocusedVerification, unresolvedFocusedVerification } from "./acceptance-focused-verification.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import crypto from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { apiBaselineCriterionEvidence as apiBaselineEvidence } from "../runtime/verification/acceptance-api-baseline.js";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
@@ -17,6 +19,7 @@ import {
   unresolvedExpansionReason
 } from "./shell-reach.ts";
 import { extractShellWritePathCandidates, shellHasFileWriteRedirection } from "./shell-write-targets.js";
+import { isProjectMutatingShellCommand, isReadOnlyTaskShellCommand } from "./readonly-inline-inspection.ts";
 import { commandMatchesVerifyPlan, createBashResultLedger, findMatchingObservedBashResult, readObservedBashResults } from "./runtime-evidence.js";
 import { findPackageRoot, findPlatformRoot, readJsonFile } from "./guard-io.js";
 import {
@@ -70,25 +73,22 @@ import {
   priorTaskAttempts, repositoryFileManifest, repositoryFileManifestDetails, resolveTaskContract, safeTaskId, summarizeAttempt, taskContractValidationErrors, taskDigestMigrationArchiveStatus,
   workPlanDependencyError, workingTreeSnapshot, workingTreeSnapshotHasUnavailableEvidence, writeTaskContract
 } from "./task-state.js";
-import { classifyRecordedVerificationFailure, classifyVerificationFailure, latestObservedVerification, meaningfulVerificationCommands, selectCompletionRecoveryClassification, selectVerificationPlan } from "./verification-intelligence.js";
+import { classifyRecordedVerificationFailure, classifyVerificationFailure, latestObservedVerification, meaningfulVerificationCommands, recordedFailureForObservation, selectCompletionRecoveryClassification, selectVerificationPlan } from "./verification-intelligence.js";
 import { executionBackendToolDecision } from "./execution-backend.js";
 import { replayTaskCheckpoints } from "./task-journal.js";
 import type { FailureClassification } from "./failure-types.ts";
 import { recordCompletionAudit, recordMutationCheckpoint, recordTaskProgressCheckpoints, recordTaskStartCheckpoint, recordVerificationCheckpoint } from "./task-runtime-audit.js";
 import {
-  applyAcceptanceRecoveryProvenance,
-  acceptanceBaselineGuidance,
-  acceptanceProofGuidance,
-  acceptanceSemanticConflicts,
-  buildAcceptanceReceipt,
-  invalidateAcceptanceReceiptAfterMutation,
-  refreshAcceptanceReceipt
+  applyAcceptanceRecoveryProvenance, acceptanceBaselineGuidance, acceptanceProofGuidance, acceptanceSemanticConflicts,
+  buildAcceptanceReceipt, invalidateAcceptanceReceiptAfterMutation, refreshAcceptanceReceipt
 } from "./acceptance-receipt.js";
 import { acceptanceLanguageAdapterForPath, isAcceptanceTestPath } from "./acceptance-language-adapters.js";
 import { allVerifyCommandsPassCurrentTree, changedSnapshotFiles, compactTaskDetails, mergeObservedTaskContext, passingVerifyCommandsForDigest, taskDeltaFilesFromSnapshot } from "./task-contract-view.js";
 import { applyRuntimeLifecycleObservation, runtimeLifecycleMode, workingTreeEvidenceDigest } from "./task-lifecycle.js";
 import { completeTaskDigestRefresh } from "./task-digest-migration.js";
 import { WORKING_TREE_DIGEST_ALGORITHM, isCurrentWorkingTreeDigest, workingTreeObservation, workingTreeSnapshotUsesCurrentAlgorithm } from "./working-tree-digest.js";
+import { currentWorkspaceRevisionDigest } from "./workspace-revision.js";
+import { captureWorkspaceVerificationSnapshot } from "./workspace-verification-snapshot.js";
 import { appendJsonlBounded } from "./state-retention.js";
 import { ensurePrivateStateDirectory, resolveLocalStatePath } from "./local-state-path.js";
 import { hasDurableContextEvidence } from "./context-evidence.js";
@@ -104,6 +104,7 @@ import {
 import { cleanSessionNameInput, currentSessionName, hasOperatorSessionName } from "../runtime/session/message-signals.ts";
 import { buildSemanticCompactionInstructions } from "../runtime/session/system-prompt.ts";
 import { buildContextPreflight, buildUsageSnapshot, formatContextPreflight, formatCount, formatPercent, formatUsageSnapshot } from "../runtime/session/usage.ts";
+import { registerTaskUsageHooks } from "../runtime/product/task-usage-hooks.ts";
 import {
   formatToolResultCaptureStatus,
   readRecentToolResultCaptures
@@ -111,6 +112,9 @@ import {
 import { RuntimeSessionState } from "../runtime/session/runtime-state.ts";
 import type { ObservedTaskContext } from "../runtime/session/runtime-state.ts";
 import { reuseCurrentTreeExactVerifier } from "../runtime/verification/exact-verifier-reuse.ts";
+import { IndependentAcceptanceRuntime } from "../runtime/verification/independent-acceptance-runtime.ts";
+import { independentAcceptanceState } from "./acceptance-independent-registry.js";
+import { independentVerificationRecovery } from "../runtime/recovery/independent-verification-recovery.ts";
 import {
   PIAGENT_TOOL_GROUPS,
   PIAGENT_TOOL_NAMES,
@@ -119,6 +123,7 @@ import {
 } from "../runtime/tools/tool-groups.ts";
 import type { PiagentToolGroup } from "../runtime/tools/tool-groups.ts";
 import { freshRequestParts, shortTaskLabel } from "../runtime/workflows/input-routing.ts";
+import { completedFollowupAcceptanceEvidenceFiles } from "../runtime/workflows/task-followup-policy.ts";
 import {
   automaticAcceptanceCriteria,
   automaticReviewLenses,
@@ -142,7 +147,8 @@ import { readRuntimeVersionMetadata, RuntimeSnapshotCapture } from "../runtime/m
 import { recordRuntimeSnapshotTelemetry } from "../runtime/model/snapshot-telemetry.ts";
 import { captureAuthenticatedModelCatalogFromContext } from "../runtime/model/authenticated-catalog.ts";
 import { normalizeOpenAiCodexReasoningPayload } from "../runtime/model/openai-codex-reasoning.ts";
-import { buildOpenAiCodexWireFingerprint } from "../runtime/model/provider-wire-fingerprint.ts";
+import { buildOpenAiCodexWireFingerprint, measureProviderPayload } from "../runtime/model/provider-wire-fingerprint.ts";
+import { registerFastModeCommand, ServiceTierRuntime } from "../runtime/model/service-tier-runtime.ts";
 import { ModelRouteRuntime, readModelRouteEvents } from "../runtime/model/model-route-runtime.ts";
 import { parentRoutingModeFromEnvironment, routingObjectiveFromEnvironment } from "../runtime/model/model-route-policy.ts";
 import { ModelSelectionProvenanceTracker } from "../runtime/model/model-selection-provenance.ts";
@@ -156,7 +162,7 @@ import { PhaseToolRuntime, phaseToolModeFromEnvironment } from "../runtime/tools
 import { parseApplyPatchTargets, registerApplyPatchTool } from "../runtime/tools/apply-patch-tool.ts";
 import { authorityReplacementState, ensureTaskAuthorityResumePolicy } from "../runtime/policy/authority-resume-policy.ts";
 import { taskAuthorityDecision } from "../runtime/policy/task-authority-runtime.ts";
-import { selectRecoveryDecision } from "../runtime/recovery/recovery-policy.ts";
+import { applyProofCapabilityHandoff, selectRecoveryDecision } from "../runtime/recovery/recovery-policy.ts";
 import type { RecoveryDecision } from "../runtime/recovery/recovery-policy.ts";
 import { inspectTaskResumeState } from "../runtime/recovery/resume-state.ts";
 import { SemanticRepairRuntime } from "../runtime/recovery/semantic-repair-runtime.ts";
@@ -169,6 +175,7 @@ import { performanceReviewToolDecision, performanceReviewToolKind } from "../run
 import { expectedModelMutationProof } from "../runtime/quality/model-mutation-proof.ts";
 import { EditFreshnessGuard, editFreshnessModeFromEnvironment } from "../runtime/quality/edit-freshness-guard.ts";
 import { captureVerifierFileSnapshot } from "../runtime/inspection/verifier-snapshot-store.ts";
+import { finalGateConfig } from "./acceptance-diagnostic-policy.ts";
 import { fallbackBasePolicy } from "./fallback-base-policy.ts";
 import { prefixCompletions, registerPiagentTool, registerRuntimeCommand, registerRuntimeTool } from "../runtime/registration/extension-registration.ts";
 import { FRESH_COMMAND_ACTIONS, FRESH_COMMAND_HELP, ONBOARDING_COMMAND_ACTIONS, WORKFLOW_COMMAND_EXCLUSIONS } from "../runtime/registration/operator-catalogs.ts";
@@ -201,7 +208,6 @@ import type {
   ContextIndexSettings,
   ExecPolicyConfig,
   ExternalActionPolicyConfig,
-  FinalGateConfig,
   MemorySettings,
   OrchestrationMode,
   OrchestrationPolicySettings,
@@ -236,7 +242,7 @@ type TaskStartParameters = {
   riskLane: "tiny" | "normal" | "high-risk";
   intakeMode?: "model" | "runtime";
   changeMode?: "source-change" | "read-only";
-  mutationPolicy?: "required" | "forbidden";
+  mutationPolicy?: "required" | "allowed" | "forbidden";
   verifyGroup?: string;
   maxAttempts?: number;
   expectedOutput: string;
@@ -297,7 +303,6 @@ const TECH_OPTIONS: TechOption[] = [
   { id: "node-typescript", label: "Node TypeScript", role: "runtime", description: "Node.js TypeScript library/tooling project.", context7Query: "typescript node.js", topics: ["typescript", "node", "testing"] },
   { id: "python", label: "Python", role: "runtime", description: "Python app/library runtime.", context7Query: "python", topics: ["packaging", "typing", "testing"] }
 ];
-
 const PROFILE_TECH_ROLES: Record<string, TechRole[]> = {
   "web-frontend": ["frontend", "database"],
   "backend-api": ["backend", "database"],
@@ -311,7 +316,6 @@ const PROFILE_TECH_ROLES: Record<string, TechRole[]> = {
   docs: ["docs"],
   generic: ["runtime"]
 };
-
 const DEFAULT_MEMORY_SETTINGS: Required<MemorySettings> = {
   enabled: true,
   mode: "manual",
@@ -324,7 +328,6 @@ const DEFAULT_MEMORY_SETTINGS: Required<MemorySettings> = {
   maxInjectedChars: 4000,
   externalPackages: []
 };
-
 const DEFAULT_CONTEXT_INDEX_SETTINGS: Required<ContextIndexSettings> = {
   enabled: true,
   path: CONTEXT_INDEX_FILE,
@@ -335,14 +338,12 @@ const DEFAULT_CONTEXT_INDEX_SETTINGS: Required<ContextIndexSettings> = {
   includeTechStack: true,
   includeMemoryPointers: true
 };
-
 const DEFAULT_RUNTIME_POLICY: Required<RuntimePolicySettings> = {
   execPolicy: "enforce",
   contextBudget: "enforce",
   toolRegistry: "advisory",
   finalGate: "enforce"
 };
-
 const DEFAULT_ORCHESTRATION_POLICY: ResolvedOrchestrationPolicy = {
   defaultMode: "solo-first",
   maxConcurrentSubagents: 1,
@@ -368,7 +369,6 @@ const DEFAULT_ORCHESTRATION_POLICY: ResolvedOrchestrationPolicy = {
     "Keep review lenses explicit so cheap review work catches drift before release."
   ]
 };
-
 const PERMISSION_PROFILE_MODES = ["read-only", "workspace-write", "trusted-full-access"] as const;
 const PERMISSION_PROFILE_ALIASES: Record<string, PermissionProfileMode> = {
   readonly: "read-only",
@@ -389,14 +389,11 @@ const WRITE_TOOL_NAMES = new Set(["write", "edit"]);
 const SHELL_TOOL_NAMES = new Set(["bash", "shell", "exec"]);
 const MAX_MCP_PROXY_ARGS_CHARS = 131_072;
 const SESSION_PERMISSION_OVERRIDES = new Map<string, PermissionProfileMode>();
-
 const DEFAULT_POLICY = fallbackBasePolicy(CONTEXT_INDEX_FILE, DEFAULT_ORCHESTRATION_POLICY);
-
 // Which platform supplies the adapters is fixed by where this file is installed,
 // so it is resolved once here rather than threaded through every profile load.
 const PLATFORM_ROOT = findPlatformRoot(path.dirname(fileURLToPath(import.meta.url)));
 const UPDATE_CHECK_MODULE = fileURLToPath(new URL("./update-check.js", import.meta.url));
-
 // The installed version, read from the package this file ships in. A maintainer
 // working in the repository is not running a release and has nothing to update
 // to, so only a tree Pi or npm placed is given a version to compare.
@@ -404,7 +401,6 @@ function installedPlatformVersion(): string | undefined {
   if (!isInstalledPlatform(PLATFORM_ROOT)) return undefined;
   return readJsonFile<{ version?: string }>(path.join(PLATFORM_ROOT, "package.json"))?.version;
 }
-
 function updateAvailabilityNotice(): string | undefined {
   const installed = installedPlatformVersion();
   if (!installed) return undefined;
@@ -1297,16 +1293,6 @@ function externalActionPolicyConfig(policy: BasePolicy): Required<ExternalAction
   };
 }
 
-function finalGateConfig(policy: BasePolicy): Required<FinalGateConfig> {
-  return {
-    defaultMode: policy.finalGate?.defaultMode ?? DEFAULT_POLICY.finalGate?.defaultMode ?? "enforce",
-    requireTaskContract: policy.finalGate?.requireTaskContract ?? true,
-    requireContextManifest: policy.finalGate?.requireContextManifest ?? true,
-    requireVerifyEvidence: policy.finalGate?.requireVerifyEvidence ?? true,
-    requireTrace: policy.finalGate?.requireTrace ?? true,
-    requirePassingVerify: policy.finalGate?.requirePassingVerify ?? true
-  };
-}
 
 function boundedInteger(value: unknown, fallback: number, minimum: number, maximum: number): number {
   const numberValue = typeof value === "number" ? value : Number(value);
@@ -1699,32 +1685,6 @@ function isTaskMutationTool(toolName: string, input: Record<string, unknown>): b
     .some((token) => tokens.has(token));
 }
 
-function isReadOnlyTaskShellCommand(
-  command: string,
-  segments: Array<{ words: string[] }>
-): boolean {
-  if (/[<>]|`|\$\(/.test(command)) {
-    return false;
-  }
-  const safeCommands = new Set(["pwd", "ls", "find", "rg", "grep", "cat", "sed", "head", "tail", "wc", "stat", "file", "test", "[", "which", "printf", "sort"]);
-  const safeGitSubcommands = new Set(["status", "diff", "log", "show", "ls-files", "rev-parse"]);
-  return segments.length > 0 && segments.every((segment) => {
-    const words = segment.words.filter(Boolean);
-    const executable = path.basename(words[0] ?? "");
-    if (executable === "sed" && words.some((word) => /^-.*i/.test(word))) return false;
-    if (executable === "find" && words.some((word) => ["-delete", "-exec", "-execdir", "-ok", "-okdir", "-fprint", "-fprint0", "-fprintf", "-fls"].includes(word))) return false;
-    if (executable === "sort" && words.slice(1).some((word) => (
-      word === "--output"
-      || word.startsWith("--output=")
-      || /^-[^-]*o/.test(word)
-    ))) return false;
-    if (safeCommands.has(executable)) return true;
-    if (executable === "git") return safeGitSubcommands.has(words[1] ?? "");
-    if (executable === "command") return words[1] === "-v";
-    return false;
-  });
-}
-
 function shellTouchesGrantedSourceCheckout(cwd: string, command: string, roots: string[]): boolean {
   if (roots.length === 0) return false;
   for (const root of roots) {
@@ -1735,37 +1695,6 @@ function shellTouchesGrantedSourceCheckout(cwd: string, command: string, roots:
     .some((candidate) => Boolean(grantedSourceCheckoutRootForPath(cwd, normalizeRelative(cwd, candidate) ?? candidate, roots)));
 }
 
-const PROJECT_MUTATING_EXECUTABLES = new Set([
-  "apply_patch", "bash", "chmod", "chown", "cp", "dd", "install", "ln", "make", "mkdir", "mv", "prename", "rename",
-  "node", "patch", "perl", "php", "python", "python3", "rm", "rmdir", "rsync", "ruby", "scp", "sh",
-  "tee", "touch", "truncate", "zsh"
-]);
-
-function isProjectMutatingShellCommand(command: string, segments: Array<{ words: string[] }>): boolean {
-  if (shellHasFileWriteRedirection(command)) return true;
-  const noAliases = new Map<string, string>();
-  for (const segment of segments) {
-    const words = segment.words.filter(Boolean);
-    if (words.length === 0) continue;
-    if (externalExecutableIndex(words, PROJECT_MUTATING_EXECUTABLES, noAliases) !== undefined) return true;
-    const executable = path.basename(words[0] ?? "").toLowerCase();
-    if (executable === "find" && words.some((word) => ["-delete", "-exec", "-execdir", "-ok", "-okdir", "-fprint", "-fprint0", "-fprintf", "-fls"].includes(word))) return true;
-    if (executable === "sed" && words.some((word) => /^-[^-]*i/.test(word) || word === "--in-place" || word.startsWith("--in-place="))) return true;
-    if (executable === "git") {
-      const subcommand = words.slice(1).find((word, index, values) => {
-        if (!word.startsWith("-")) return index === 0 || !["-C", "-c", "--git-dir", "--work-tree"].includes(values[index - 1]);
-        return false;
-      });
-      if (["apply", "checkout", "clean", "mv", "reset", "restore", "rm", "switch"].includes(subcommand ?? "")) return true;
-    }
-    if (["npm", "pnpm", "yarn", "bun"].includes(executable)) {
-      const subcommand = words.find((word, index) => index > 0 && !word.startsWith("-"));
-      if (["add", "ci", "install", "link", "remove", "uninstall", "update", "upgrade"].includes(subcommand ?? "")) return true;
-    }
-  }
-  return false;
-}
-
 const EXPLICIT_SHELL_MUTATORS = new Set([
   "apply_patch", "chmod", "chown", "cp", "dd", "install", "ln", "mkdir", "mv", "patch", "prename", "rename",
   "rm", "rmdir", "rsync", "scp", "tee", "touch", "truncate"
@@ -1937,18 +1866,20 @@ function recordObservedTaskVerification(
   },
   pendingContext: ObservedTaskContext[],
   maxManifestFiles: number, shellSnapshotBefore?: Record<string, string>,
-  eventTree?: ReturnType<typeof workingTreeObservation>,
-  readProtectedPaths: string[] = []
+  eventTree?: ReturnType<typeof captureWorkspaceVerificationSnapshot>,
+  readProtectedPaths: string[] = [], preWorkspaceRevisionDigest?: string, diagnosticFocused = false
 ): TaskContract | undefined {
   const task = activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined;
   if (!task || task.trace.outcome !== "pending") return;
   const command = String(observed.normalizedCommand ?? observed.command ?? "").trim();
   const observedAtMs = Date.parse(observed.recordedAt ?? "");
   const taskCreatedAtMs = Date.parse(task.createdAt);
+  const matchedProfileCommand = commandMatchesVerifyPlan(command, task.verifyCommands);
+  const focusedTest = diagnosticFocused && observedFocusedTestSummary(observed.outputText);
   if (
     !command
     || !observed.commandHash
-    || !commandMatchesVerifyPlan(command, task.verifyCommands)
+    || (!matchedProfileCommand && !focusedTest)
     || !Number.isFinite(observedAtMs)
     || !Number.isFinite(taskCreatedAtMs)
     || observedAtMs < taskCreatedAtMs
@@ -1957,6 +1888,7 @@ function recordObservedTaskVerification(
   if (!eventTree?.proofCapable) return;
   const currentDigests = eventTree.snapshot as Record<string, string>;
   const currentDigest = eventTree.digest;
+  const workspaceRevisionDigest = eventTree.workspaceRevisionDigest ?? undefined;
   const preWorkingTreeDigest = shellSnapshotBefore && workingTreeSnapshotUsesCurrentAlgorithm(shellSnapshotBefore) ? workingTreeEvidenceDigest(shellSnapshotBefore) : undefined;
   const exitCode = Number.isInteger(observed.exitCode) ? observed.exitCode as number : observed.isError ? 1 : 0;
   const classification = classifyVerificationFailure(observed.outputText, exitCode);
@@ -1964,6 +1896,7 @@ function recordObservedTaskVerification(
     evidence.command.trim() === command
     && evidence.exitCode === exitCode
     && evidence.workingTreeDigest === currentDigest && evidence.observedAt === observed.recordedAt
+    && evidence.workspaceRevisionDigest === workspaceRevisionDigest && evidence.preWorkspaceRevisionDigest === preWorkspaceRevisionDigest
   ));
   const contextAdded = mergeObservedTaskContext(task, pendingContext, maxManifestFiles, redactText);
   if (!duplicate) {
@@ -1972,16 +1905,17 @@ function recordObservedTaskVerification(
     task.verifyEvidence.push({
       command: redactText(command),
       exitCode,
-      summary: `Runtime observed configured verifier exit ${exitCode} (${classification.category}${classification.retryable ? ", retryable" : ""}).`,
+      summary: `Runtime observed ${matchedProfileCommand ? "configured" : "focused"} verifier exit ${exitCode} (${classification.category}${classification.retryable ? ", retryable" : ""}).`,
       recordedAt: evidenceRecordedAt,
       observed: true,
       observedAt,
       isError: observed.isError === true,
-      matchedProfileCommand: true,
+      matchedProfileCommand,
       preWorkingTreeDigest,
-      workingTreeDigest: currentDigest
+      workingTreeDigest: currentDigest,
+      preWorkspaceRevisionDigest, workspaceRevisionDigest
     });
-    task.verifyEvidence = task.verifyEvidence.slice(-100);
+    task.verifyEvidence = diagnosticFocused ? retainFocusedVerification(task.verifyEvidence, currentDigest, workspaceRevisionDigest) : task.verifyEvidence.slice(-100);
     try {
       captureVerifierFileSnapshot({
         projectRoot: ctx.cwd, taskId: task.taskId, taskRunId: task.taskRunId, sessionId: task.sessionId,
@@ -1994,18 +1928,20 @@ function recordObservedTaskVerification(
     }
   }
 
-  const hasChanges = taskChangedFileEvidence(ctx.cwd, task, currentDigests).expected.length > 0;
-  const allPassing = hasChanges && allVerifyCommandsPassCurrentTree(task, currentDigest);
-  const lifecycle = hasChanges
+  const taskLocalDelta = taskChangedFileEvidence(ctx.cwd, task, currentDigests).expected;
+  const hasChanges = taskLocalDelta.length > 0;
+  const verificationCanSettleSourceTask = hasChanges || task.mutationPolicy === "allowed";
+  const allPassing = verificationCanSettleSourceTask && allVerifyCommandsPassCurrentTree(task, currentDigest, workspaceRevisionDigest ?? null);
+  const lifecycle = verificationCanSettleSourceTask
     ? applyRuntimeLifecycleObservation(task, allPassing ? "verification-complete" : "verification-pending", nowIso())
     : { changed: false, mode: runtimeLifecycleMode(task) };
   const acceptance = refreshAcceptanceReceipt(task, {
-    cwd: ctx.cwd,
-    changedFiles: taskChangedFileEvidence(ctx.cwd, task, currentDigests).expected,
+    cwd: ctx.cwd, apiBaselineEvidence,
+    changedFiles: taskAcceptanceEvidenceFiles(ctx.cwd, task, currentDigests, taskLocalDelta),
     currentWorkingTreeDigest: currentDigest
   });
   task.acceptanceReceipt = acceptance.task.acceptanceReceipt;
-  if (!task.workingTreeDigestMigration || (shellSnapshotBefore && changedSnapshotFiles(shellSnapshotBefore, currentDigests).length === 0)) Object.assign(task, completeTaskDigestRefresh(task, currentDigest));
+  if (!task.workingTreeDigestMigration || (shellSnapshotBefore && changedSnapshotFiles(shellSnapshotBefore, currentDigests).length === 0)) Object.assign(task, completeTaskDigestRefresh(task, currentDigest, workspaceRevisionDigest ?? null));
   if (duplicate && contextAdded.length === 0 && !lifecycle.changed) return task;
 
   const written = writeTask(ctx.cwd, task);
@@ -2035,7 +1971,8 @@ function recordObservedTaskVerification(
       retryable: classification.retryable,
       failureClassification: classification,
       preWorkingTreeDigest,
-      workingTreeDigest: currentDigest
+      workingTreeDigest: currentDigest,
+      preWorkspaceRevisionDigest, workspaceRevisionDigest
     }
   });
   return written;
@@ -2085,14 +2022,14 @@ function completionTaskProjection(
     failureReason: undefined,
     ruledOut: undefined,
     trace: {
-      outcome: "completed",
+      outcome: "completed" as const,
       notes: "Runtime finalized from observed context, working-tree changes, current verification, and completed work-plan evidence.",
       recordedAt: nowIso()
     }
   };
   return refreshAcceptanceReceipt(projected, {
-    cwd,
-    changedFiles,
+    cwd, apiBaselineEvidence,
+    changedFiles: taskAcceptanceEvidenceFiles(cwd, projected, finalFileDigests, changedFiles),
     currentWorkingTreeDigest: workingTreeEvidenceDigest(finalFileDigests)
   }).task as TaskContract;
 }
@@ -3505,6 +3442,20 @@ function taskChangedFileEvidence(
   };
 }
 
+function taskAcceptanceEvidenceFiles(
+  cwd: string,
+  task: TaskContract,
+  currentDigests: Record<string, string>,
+  taskLocalDelta: string[] = taskChangedFileEvidence(cwd, task, currentDigests).expected
+): string[] {
+  return completedFollowupAcceptanceEvidenceFiles(
+    task,
+    listTaskContracts(cwd) as TaskContract[],
+    taskLocalDelta,
+    currentDigests
+  );
+}
+
 function exactReviewPathCoverage(expectedPaths: string[], reviewedPaths: string[] | undefined): boolean {
   const expected = [...new Set(expectedPaths)].sort();
   const reviewed = [...new Set(reviewedPaths ?? [])].sort();
@@ -3543,8 +3494,9 @@ function evaluateTaskGate(
   warnings: string[];
   currentWorkingTreeDigest?: string;
   changedFileEvidence?: ReturnType<typeof taskChangedFileEvidence>;
+  acceptanceProof?: { mode: "enforce" | "diagnostic"; pendingCriterionIds: string[]; missing: string[] };
 } {
-  const finalGate = finalGateConfig(policy);
+  const finalGate = finalGateConfig(policy, DEFAULT_POLICY);
   const missing: string[] = [];
   const warnings: string[] = [];
   if (!task) {
@@ -3552,14 +3504,24 @@ function evaluateTaskGate(
   }
   const currentDigests = options.currentDigests ?? workingTreeSnapshot(cwd) as Record<string, string>;
   const currentWorkingTreeDigest = options.currentWorkingTreeDigest ?? workingTreeEvidenceDigest(currentDigests);
+  const independentState = independentAcceptanceState(cwd, task, currentWorkingTreeDigest);
+  if (independentState.block) missing.push(independentState.block);
+  const compositeFacts = new Set<string>();
+  for (const [id, assessment] of independentState.assessments) {
+    if (assessment.verdict !== "pass") missing.push(`independent contract evidence (${id}:${assessment.verdict}${assessment.executionDiagnostics?.reasons.length ? `; ${assessment.executionDiagnostics.reasons.join(", ")}` : ""})`);
+    else if (assessment.assurance === "bounded-composite-contract-tested" && Array.isArray(assessment.factKinds)) {
+      for (const kind of assessment.factKinds) if (typeof kind === "string") compositeFacts.add(kind);
+    }
+  }
+  const compositeContext = compositeFacts.has("context-current"), compositeVerifier = compositeFacts.has("project-verifier-current");
   if (task.workingTreeDigestAlgorithm !== WORKING_TREE_DIGEST_ALGORITHM || task.workingTreeDigestMigration?.status === "verification-refresh-required" || !workingTreeSnapshotUsesCurrentAlgorithm(currentDigests) || !isCurrentWorkingTreeDigest(currentWorkingTreeDigest) || currentWorkingTreeDigest !== workingTreeEvidenceDigest(currentDigests) || Object.values(task.baselineFileDigests).some((digest) => !isCurrentWorkingTreeDigest(digest)) || (task.workingTreeDigestMigration && (!taskDigestMigrationArchiveStatus(cwd, task).valid || replayTaskCheckpoints(cwd, task.taskRunId, task).corruptions.length > 0))) missing.push("current working-tree digest evidence");
   if (workingTreeSnapshotHasUnavailableEvidence(currentDigests)) missing.push("complete working-tree content evidence");
   if (taskContractValidationErrors(task).length > 0) missing.push("valid session-bound task contract v2");
   if (task.attempt > task.maxAttempts) missing.push(`attempt within maxAttempts (${task.attempt}/${task.maxAttempts})`);
   const plannedVerifyCommands = meaningfulVerificationCommands(task.verifyCommands);
-  if (task.changeMode === "source-change" && plannedVerifyCommands.length === 0) missing.push("meaningful verify command");
-  if (finalGate.requireContextManifest && !hasDurableContextEvidence(task)) missing.push("context manifest");
-  if (task.changeMode === "source-change" && finalGate.requireVerifyEvidence && task.verifyEvidence.length === 0) missing.push("verify evidence");
+  if (task.changeMode === "source-change" && plannedVerifyCommands.length === 0 && !compositeVerifier) missing.push("meaningful verify command");
+  if (finalGate.requireContextManifest && !hasDurableContextEvidence(task) && !compositeContext) missing.push("context manifest");
+  if (task.changeMode === "source-change" && finalGate.requireVerifyEvidence && task.verifyEvidence.length === 0 && !compositeVerifier) missing.push("verify evidence");
   if (task.verifyEvidence.some((evidence) => evidence.observed !== true)) {
     warnings.push("Unobserved verify evidence is ignored by the passing verify gate.");
   }
@@ -3574,19 +3536,21 @@ function evaluateTaskGate(
     warnings.push("Verification evidence from a different working-tree snapshot is stale and is ignored.");
   }
   let missingVerifyCommands: string[] = [];
-  if (task.changeMode === "source-change" && finalGate.requirePassingVerify && plannedVerifyCommands.length > 0) {
-    const passingCommands = passingVerifyCommandsForDigest(task, currentWorkingTreeDigest);
+  if (task.changeMode === "source-change" && finalGate.requirePassingVerify && plannedVerifyCommands.length > 0 && !compositeVerifier) {
+    const passingCommands = passingVerifyCommandsForDigest(task, currentWorkingTreeDigest, currentWorkspaceRevisionDigest(cwd));
     missingVerifyCommands = plannedVerifyCommands.filter((command) => !passingCommands.has(command.trim()));
     if (missingVerifyCommands.length > 0) missing.push(`observed passing verify evidence for every configured command (${missingVerifyCommands.length} missing)`);
   }
+  if (finalGate.acceptanceProofMode === "diagnostic" && unresolvedFocusedVerification(task.verifyEvidence, currentWorkingTreeDigest, currentWorkspaceRevisionDigest(cwd)).length > 0) missing.push("current passing rerun of failed focused verification");
   if (finalGate.requireTrace && task.trace.outcome !== "completed") missing.push("completed final trace");
   const incompleteSteps = (task.workPlan ?? []).filter((step) => step.status === "pending" || step.status === "in-progress" || step.status === "failed");
   if (task.trace.outcome === "completed" && incompleteSteps.length > 0) {
     missing.push(`completed work plan (${incompleteSteps.map((step) => `${step.id}:${step.status}`).join(", ")})`);
   }
   const changedFileEvidence = taskChangedFileEvidence(cwd, task, currentDigests);
+  const acceptanceEvidenceFiles = taskAcceptanceEvidenceFiles(cwd, task, currentDigests, changedFileEvidence.expected);
   if (task.changeMode === "source-change" && task.trace.outcome === "completed" && task.mutationPolicy !== "forbidden") {
-    if (task.changedFiles.length === 0) missing.push("changed files");
+    if (task.mutationPolicy !== "allowed" && task.changedFiles.length === 0) missing.push("changed files");
     if (changedFileEvidence.undeclared.length > 0) missing.push(`declared observed changes (${changedFileEvidence.undeclared.join(", ")})`);
     if (changedFileEvidence.unsupportedClaims.length > 0) missing.push(`supported changed-file claims (${changedFileEvidence.unsupportedClaims.join(", ")})`);
     if (changedFileEvidence.outsideScope.length > 0) {
@@ -3597,19 +3561,30 @@ function evaluateTaskGate(
     missing.push(`mutation-forbidden task has observed changes (${changedFileEvidence.expected.join(", ")})`);
   }
   const acceptance = refreshAcceptanceReceipt(task, {
-    cwd,
-    changedFiles: changedFileEvidence.expected,
+    cwd, apiBaselineEvidence,
+    changedFiles: acceptanceEvidenceFiles,
     currentWorkingTreeDigest
   });
   const semanticEnforcement = taskAuthorityDecision(task, "CAP-13", "block").allowed;
+  // Runtime-derived critical proof gates completion. A zero-delta review
+  // uses its strictly bound evidence scope without claiming a new mutation.
+  // Neutral artifacts with missing content proof use source-proof-required;
+  // unsupported language policy remains under the existing CAP-13 authority.
+  const proofMissing: string[] = [];
+  const runtimeCriticalProofEnforcement = task.changeMode === "source-change"
+    && task.acceptanceReceipt?.source === "runtime";
   const abstainedIds = new Set(acceptance.adapterAbstained.map((criterion) => criterion.id));
-  const adapterCritical = acceptance.criticalMissing.filter((criterion) => abstainedIds.has(criterion.id));
-  const linkedCritical = acceptance.criticalMissing.filter((criterion) => !abstainedIds.has(criterion.id));
-  if (semanticEnforcement && linkedCritical.length > 0) missing.push(`critical acceptance evidence (${linkedCritical.map((criterion) => `${criterion.id}:${criterion.obligation}`).join(", ")})`);
-  if (semanticEnforcement && adapterCritical.length > 0) missing.push(`critical acceptance evidence adapter-unresolved (${adapterCritical.map((criterion) => `${criterion.id}:${criterion.obligation}`).join(", ")}); remedy: add a direct-relative focused test or configure a deterministic adapter`);
+  const independentIds = new Set(acceptance.independentRequired.map((criterion) => criterion.id));
+  const sourceProofIds = new Set(acceptance.sourceProofRequired.map((criterion) => criterion.id));
+  const adapterCritical = acceptance.criticalMissing.filter((criterion) => abstainedIds.has(criterion.id) && !independentIds.has(criterion.id));
+  const linkedCritical = acceptance.criticalMissing.filter((criterion) => !abstainedIds.has(criterion.id) && !independentIds.has(criterion.id) && !sourceProofIds.has(criterion.id));
+  if ((semanticEnforcement || runtimeCriticalProofEnforcement) && sourceProofIds.size > 0) proofMissing.push(`critical acceptance evidence source-proof-required (${acceptance.sourceProofRequired.map((criterion) => `${criterion.id}:${criterion.obligation}`).join(", ")}); remedy: source proof remains unestablished after current focused tests passed; seek assessment, not source repair without a counterexample`);
+  if ((semanticEnforcement || runtimeCriticalProofEnforcement) && independentIds.size > 0) proofMissing.push(`critical acceptance evidence independent-required (${acceptance.independentRequired.map((criterion) => `${criterion.id}:${criterion.obligation}`).join(", ")}); remedy: an approved independent assessment must cover every clause; missing proof is not an observed source defect`);
+  if ((semanticEnforcement || runtimeCriticalProofEnforcement) && linkedCritical.length > 0) proofMissing.push(`critical acceptance evidence (${linkedCritical.map((criterion) => `${criterion.id}:${criterion.obligation}`).join(", ")})`);
+  if (semanticEnforcement && adapterCritical.length > 0) proofMissing.push(`critical acceptance evidence adapter-unresolved (${adapterCritical.map((criterion) => `${criterion.id}:${criterion.obligation}`).join(", ")}); remedy: add a direct-relative focused test or configure a deterministic adapter`);
   const acceptanceConflicts = acceptanceSemanticConflicts(task, {
     cwd,
-    changedFiles: changedFileEvidence.expected
+    changedFiles: acceptanceEvidenceFiles
   });
   if (semanticEnforcement && acceptanceConflicts.length > 0) {
     missing.push(`acceptance semantic conflicts (${acceptanceConflicts.join(", ")})`);
@@ -3619,11 +3594,16 @@ function evaluateTaskGate(
   if (semanticEnforcement && acceptance.adapterAbstained.length > 0) {
     warnings.push(`Acceptance proof adapter abstained; rigorous criteria remain pending and hand off without an automatic model retry: ${acceptance.adapterAbstained.map((criterion) => `${criterion.id}:${criterion.obligation}`).join(", ")}`);
   }
-  if (!semanticEnforcement && (acceptance.criticalMissing.length > 0 || acceptanceConflicts.length > 0)) warnings.push("Acceptance projection is advisory under the pinned task authority and cannot block completion.");
+  if (!semanticEnforcement && (adapterCritical.length > 0 || acceptanceConflicts.length > 0)) warnings.push("Adapter-unknown acceptance proof and semantic conflicts remain advisory under the pinned task authority; known runtime-linked critical proof still gates source-task completion.");
   if (normalMissing.length > 0) {
     warnings.push(`Acceptance criteria pending evidence: ${normalMissing.map((criterion) => `${criterion.id}:${criterion.obligation}`).join(", ")}`);
   }
-  return { decision: missing.length === 0 ? "pass" : "fail", missing, missingVerifyCommands, warnings, currentWorkingTreeDigest, changedFileEvidence };
+  const acceptanceProof = { mode: finalGate.acceptanceProofMode,
+    pendingCriterionIds: acceptance.missing.map(criterion => criterion.id), missing: proofMissing };
+  if (finalGate.acceptanceProofMode === "diagnostic" && acceptanceProof.pendingCriterionIds.length > 0) {
+    warnings.push(`Diagnostic acceptance: ${acceptanceProof.pendingCriterionIds.length} criteria remain unproved; no quality claim. ${proofMissing.join("; ")}`);
+  } else missing.push(...proofMissing);
+  return { decision: missing.length === 0 ? "pass" : "fail", missing, missingVerifyCommands, warnings, currentWorkingTreeDigest, changedFileEvidence, ...(finalGate.acceptanceProofMode === "diagnostic" ? { acceptanceProof } : {}) };
 }
 
 function appendTrace(cwd: string, payload: Record<string, unknown>): void {
@@ -3795,15 +3775,28 @@ export default function piagentGuard(pi: ExtensionAPI) {
   const routingObjective = routingObjectiveFromEnvironment(process.env.PIAGENT_ROUTING_OBJECTIVE);
   const autoContextEnabled = environmentFeatureEnabled("PIAGENT_AUTO_CONTEXT");
   const autoRecoveryEnabled = environmentFeatureEnabled("PIAGENT_AUTO_RECOVERY");
-  const runtimeState = new RuntimeSessionState({
-    maxObservedContext: contextBudgetConfig(policy).maxManifestFiles
-  });
+  const independentVerificationConfigPath = process.env.PIAGENT_INDEPENDENT_VERIFICATION_CONFIG,
+    runtimeState = new RuntimeSessionState({ maxObservedContext: contextBudgetConfig(policy).maxManifestFiles });
+  const independentAcceptance = new IndependentAcceptanceRuntime({ state: runtimeState, installedRoot: PLATFORM_ROOT,
+    configPath: independentVerificationConfigPath,
+    writeTask,
+    activeTask: (ctx) => activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined,
+    authorizeSourceRead: (ctx, sourcePath) => {
+      if (!ctx.isProjectTrusted()) return false;
+      const profile = loadProfileFromContext(ctx), paths = effectiveProtectedPaths(policy, profile);
+      const capabilities = verifyProjectCapabilityState(extensionDir, ctx.cwd, true, { sessionId: ctx.sessionManager.getSessionId() });
+      if (!capabilities.ok) return false;
+      const permission = resolvePermissionProfile(profile, policy, permissionOverrideFromContext(ctx));
+      return !evaluatePathLikeToolAccess(ctx.cwd, "read", { path: sourcePath }, paths.writeProtectedPaths, paths.readProtectedPaths,
+        paths.readOnlyPaths, permission.mode === "trusted-full-access" ? undefined : capabilities.filesystemRead).block;
+    } });
   const editFreshnessGuard = new EditFreshnessGuard(editFreshnessModeFromEnvironment(process.env.PIAGENT_EDIT_FRESHNESS));
   const sourceMutationGuardBindings = createSourceMutationGuardBindings(policy, loadProfileFromContext);
   const runtimeSnapshotCapture = new RuntimeSnapshotCapture(), runtimeVersions = readRuntimeVersionMetadata(PLATFORM_ROOT);
   const solverShadow = solverMode === "off" ? undefined : new SolverShadowRuntime(solverMode);
   const modelRouteRuntime = new ModelRouteRuntime(parentRoutingMode, routingObjective);
   const modelSelectionProvenance = new ModelSelectionProvenanceTracker();
+  const serviceTierRuntime = new ServiceTierRuntime({ environmentValue: process.env.PIAGENT_FAST_MODE });
   const trajectoryRuntime = new TrajectoryRuntime(), phaseToolRuntime = new PhaseToolRuntime(pi, dynamicToolsEnabled ? phaseToolModeFromEnvironment(process.env.PIAGENT_PHASE_TOOLS) : "off", telemetry, (ctx) => {
     const task = activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined; return task && authorityReplacementState(ctx.cwd, task).required ? "new-attempt-required" : task?.workingTreeDigestMigration?.status;
   }, (ctx) => {
@@ -3847,8 +3840,25 @@ export default function piagentGuard(pi: ExtensionAPI) {
         providerReasoningReasonCode: normalized.reasonCode
       });
     }
+    const serviceTier = serviceTierRuntime.applyProviderRequest(
+      pi,
+      ctx,
+      normalized.changed ? normalized.payload : event.payload
+    );
+    if (serviceTier.receipt.enabled || serviceTier.observationChanged) {
+      telemetry(ctx, {
+        event: "provider_request_service_tier",
+        fastMode: serviceTier.receipt.mode,
+        requestedServiceTier: serviceTier.receipt.requestedServiceTier,
+        observedRequestServiceTier: serviceTier.receipt.observedRequestServiceTier,
+        providerResponseServiceTier: serviceTier.receipt.providerResponseServiceTier,
+        providerResponseEvidence: serviceTier.receipt.providerResponseEvidence,
+        applied: serviceTier.receipt.applied,
+        reasonCode: serviceTier.receipt.reasonCode
+      });
+    }
     const wire = buildOpenAiCodexWireFingerprint({
-      payload: normalized.changed ? normalized.payload : event.payload,
+      payload: serviceTier.payload,
       provider: ctx.model?.provider,
       modelId: ctx.model?.id,
       workingDirectory: ctx.cwd,
@@ -3873,10 +3883,11 @@ export default function piagentGuard(pi: ExtensionAPI) {
         providerTextVerbosity: wire.textVerbosity,
         providerToolChoiceKind: wire.toolChoiceKind,
         providerToolChoiceHash: wire.toolChoiceHash,
-        requestPrefixFingerprint: wire.requestPrefixFingerprint
+        requestPrefixFingerprint: wire.requestPrefixFingerprint,
+        payloadMeasurement: measureProviderPayload(serviceTier.payload)
       });
     }
-    return normalized.changed ? normalized.payload : undefined;
+    return normalized.changed || serviceTier.changed ? serviceTier.payload : undefined;
   });
 
   function freshModelRouteBoundary(ctx: ExtensionContext): boolean {
@@ -3957,6 +3968,15 @@ export default function piagentGuard(pi: ExtensionAPI) {
     }
   }
 
+  function preferApplyPatchBeforeWriters(toolNames: string[]): string[] {
+    if (!toolNames.includes("apply_patch")) return [...toolNames];
+    const withoutPatch = toolNames.filter((toolName) => toolName !== "apply_patch");
+    const firstWriter = withoutPatch.findIndex((toolName) => toolName === "edit" || toolName === "write");
+    if (firstWriter < 0) return [...toolNames];
+    withoutPatch.splice(firstWriter, 0, "apply_patch");
+    return withoutPatch;
+  }
+
   function activateToolGroups(ctx: ExtensionContext, groups: PiagentToolGroup[], additive = false): string[] {
     const current = pi.getActiveTools();
     if (!dynamicToolsEnabled) return current;
@@ -3975,7 +3995,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
       }
     }
     const ordered = [
-      ...current.filter((toolName) => selected.has(toolName) && !PIAGENT_TOOL_NAMES.has(toolName)),
+      ...preferApplyPatchBeforeWriters(current.filter((toolName) => selected.has(toolName) && !PIAGENT_TOOL_NAMES.has(toolName))),
       ...PIAGENT_TOOL_ORDER.filter((toolName) => selected.has(toolName))
     ];
     const unchanged = ordered.length === current.length && ordered.every((toolName, index) => toolName === current[index]);
@@ -4004,22 +4024,22 @@ export default function piagentGuard(pi: ExtensionAPI) {
     let recordedClassification: FailureClassification | undefined;
     try {
       const replay = replayTaskCheckpoints(ctx.cwd, task.taskRunId, task);
-      if (replay.corruptions.length === 0) {
-        const checkpoint = replay.checkpoints
-          .filter((item) => item.phase === "verify" && item.status === "failed")
-          .at(-1) as any;
-        recordedClassification = checkpoint?.evidence?.failureClassification as FailureClassification | undefined;
-      }
+      if (replay.corruptions.length === 0 && failed) recordedClassification = recordedFailureForObservation(
+        replay.checkpoints, failed, currentTreeDigest, currentWorkspaceRevisionDigest(ctx.cwd)
+      ) as FailureClassification | undefined;
     } catch {
       // A missing/corrupt journal cannot grant recovery mutation; the fallback
       // classifier remains fail-closed for unknown evidence.
     }
-    const classification = selectCompletionRecoveryClassification(
+    const gateClassification = selectCompletionRecoveryClassification(
       recordedClassification,
       gate?.missing,
       summary,
       failed?.exitCode ?? 1
     );
+    const independentRecovery = independentVerificationRecovery(ctx.cwd, task, currentTreeDigest ?? workingTreeEvidenceDigest(workingTreeSnapshot(ctx.cwd)));
+    const classification = gateClassification.category === "scope-protected-path"
+      ? gateClassification : independentRecovery?.classification ?? gateClassification;
     const trajectory = trajectoryRuntime.status(ctx.cwd, task.taskRunId);
     // Task scope is a retrieval/review hint, not filesystem authority. Recovery
     // may update a dependency or config file when repository evidence requires
@@ -4037,16 +4057,16 @@ export default function piagentGuard(pi: ExtensionAPI) {
       classification,
       currentPhase: trajectory.enforcementSafe ? trajectory.phase ?? "verify" : "handoff",
       history: runtimeState.recoveryHistory(task.taskId),
-      proposedHypothesisRef: classification.reasonCodes[0] ? `reason:${classification.reasonCodes[0]}` : null,
+      proposedHypothesisRef: independentRecovery?.hypothesisRef ?? (classification.reasonCodes[0] ? `reason:${classification.reasonCodes[0]}` : null),
       exactVerifierAvailable: (gate?.missingVerifyCommands.length ?? task.verifyCommands.length) > 0,
       currentTreeMatchesEvidence: currentTreeDigest && latestExactVerifier?.workingTreeDigest
-        ? currentTreeDigest === latestExactVerifier.workingTreeDigest
+        ? currentTreeDigest === latestExactVerifier.workingTreeDigest && latestExactVerifier.preWorkspaceRevisionDigest === currentWorkspaceRevisionDigest(ctx.cwd)
+          && latestExactVerifier.workspaceRevisionDigest === latestExactVerifier.preWorkspaceRevisionDigest
         : true,
-      dependencyMutationAuthorized
+      dependencyMutationAuthorized,
+      independentDisposition: independentRecovery?.independentDisposition
     });
-    return gate?.missing.some((item) => /^critical acceptance evidence adapter-unresolved\b/i.test(item))
-      ? { ...selected, action: "handoff", continuation: "none", nextPhase: null, sourceMutationAllowed: false, reasonCodes: ["unknown-diagnostic-exhausted"] }
-      : selected;
+    return applyProofCapabilityHandoff(selected, gate?.missing, Boolean(independentRecovery));
   }
 
   function trajectoryRecoveryOptions(ctx: ExtensionContext, task: TaskContract, options: any): any {
@@ -4112,7 +4132,15 @@ export default function piagentGuard(pi: ExtensionAPI) {
       })));
     },
     telemetry,
-    afterStart: async (ctx) => { sourceMutationGuardBindings.bind(ctx); await activityInspector.refresh(ctx); }
+    afterStart: async (ctx) => {
+      await independentAcceptance.activate(ctx);
+      const serviceTier = serviceTierRuntime.restore(ctx);
+      if (serviceTier.enabled && serviceTier.reasonCode === "provider-not-supported") {
+        ctx.ui.notify("Piagent Fast mode is enabled, but the active provider is not OpenAI Codex; no service tier was changed.", "warning");
+      }
+      sourceMutationGuardBindings.bind(ctx);
+      await activityInspector.refresh(ctx);
+    }
   });
 
   registerSessionHooks(pi, {
@@ -4126,13 +4154,17 @@ export default function piagentGuard(pi: ExtensionAPI) {
     flushObservedTaskContext,
     onTurnEnd: activityInspector.refresh,
     onAgentSettled: activityInspector.refresh,
-    beforeShutdown: (ctx) => {
+    beforeShutdown: async (ctx) => {
+      await independentAcceptance.clear(ctx);
+      serviceTierRuntime.forget(ctx);
       sourceMutationGuardBindings.unbind(ctx);
       editFreshnessGuard.clear(ctx);
       activityInspector.dispose(ctx);
       sessionCapabilityDigests.delete(`${ctx.cwd}\0${ctx.sessionManager.getSessionId()}`);
     }
   });
+  registerTaskUsageHooks(pi, { activeTask: (ctx) => activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined, telemetry });
+  pi.on("turn_end", (event, ctx) => independentAcceptance.observeTurnEnd(ctx, event.message));
 
   registerInputHook(pi, {
     state: runtimeState,
@@ -4184,10 +4216,15 @@ export default function piagentGuard(pi: ExtensionAPI) {
 
   registerCompletionHook(pi, {
     state: runtimeState,
+    prepareIndependentAcceptance: (ctx, task, response) => independentAcceptance.prepare(ctx, task, response),
+    deferIndependentCompletion: (ctx, task, response, finalizer) => independentAcceptance.deferCompletion(ctx, task, response, finalizer),
+    projectIndependentLifecycle: (ctx, task, candidate) => independentAcceptance.projectLifecycle(ctx, task, candidate),
+    nativeRefusalFallbackAllowed: () => !independentVerificationConfigPath,
     maxManifestFiles: contextBudgetConfig(policy).maxManifestFiles,
     activeTask: (ctx) => activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined,
     flushObservedTaskContext,
     completionProjection: completionTaskProjection,
+    acceptanceEvidenceFiles: taskAcceptanceEvidenceFiles,
     evaluateGate: (cwd, task, currentDigests, currentDigest) => {
       const gate = evaluateTaskGate(cwd, task, policy, { currentDigests, currentWorkingTreeDigest: currentDigest });
       const repairBlock = (taskAuthorityDecision(task, "CAP-13", "block").allowed
@@ -4219,7 +4256,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
     redactText,
     observedTaskContext: observedTaskContextFromToolResult,
     recordObservedTaskChanges,
-    recordObservedTaskVerification,
+    recordObservedTaskVerification: (...args) => recordObservedTaskVerification(...args, policy.finalGate?.acceptanceProofMode === "diagnostic"),
     extractLikelyPath: extractLikelyPathFromInput,
     mutationTargets: taskMutationTargets,
     isShellTool: (toolName) => SHELL_TOOL_NAMES.has(toolName),
@@ -4298,7 +4335,8 @@ export default function piagentGuard(pi: ExtensionAPI) {
         });
         return { block: true, reason: `Blocked ${event.toolName}: ${helperPreflight.reason} Do not retry this helper; continue in the parent.` };
       }
-      const verifierReuse = reuseCurrentTreeExactVerifier({ cwd: ctx.cwd, task, toolName: event.toolName, toolInput, sessionEntries: ctx.sessionManager.getEntries() as unknown[] });
+      const verifierReuse = reuseCurrentTreeExactVerifier({ cwd: ctx.cwd, task, toolName: event.toolName, toolInput, sessionEntries: ctx.sessionManager.getEntries() as unknown[],
+        getHostProjectVerificationDigest: (snapshot, command) => task ? runtimeState.projectVerification.currentDigest(ctx, task, snapshot, command) : null });
       if (verifierReuse.reused) {
         telemetry(ctx, { event: "verifier_evidence_reused", recordedAt: nowIso(), taskRunId: task?.taskRunId, toolCallId: event.toolCallId, reasonCode: verifierReuse.reasonCode, commandDigest: verifierReuse.commandDigest, workingTreeDigest: verifierReuse.workingTreeDigest }); return;
       }
@@ -4329,7 +4367,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
       const expectedReviewPaths = taskDeltaFilesFromSnapshot(task, currentSnapshot);
       const targets = targetInspection.targets;
       const boundedTargetMutation = targets.length > 0;
-      const verifierCurrent = allVerifyCommandsPassCurrentTree(task, currentDigest);
+      const verifierCurrent = allVerifyCommandsPassCurrentTree(task, currentDigest, currentWorkspaceRevisionDigest(ctx.cwd));
 
       if (phase.phase === "verify" && boundedTargetMutation && semanticRepairEnabled && semanticRepairRuntime.prepare({
         ctx, task, event, currentDigest, currentDeltaPaths: expectedReviewPaths, targetPaths: targets,
@@ -4579,7 +4617,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
     const governedTaskProfile = !profileMode.startsWith("unprofiled") && !profileMode.includes("unreadable");
     const taskContractRequired = governedTaskProfile
       && runtime.finalGate === "enforce"
-      && finalGateConfig(policy).requireTaskContract;
+      && finalGateConfig(policy, DEFAULT_POLICY).requireTaskContract;
     if (sessionTask?.trace.outcome === "pending" && (sessionTask.changeMode === "read-only" || sessionTask.mutationPolicy === "forbidden")
       && !SHELL_TOOL_NAMES.has(event.toolName) && isTaskMutationTool(event.toolName, toolInput)) {
       return {
@@ -4620,7 +4658,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
           reason: "Shared source checkouts are shell-inaccessible. Inspect the exact session-granted checkout with read, grep, find, or ls; cache mutation is never authorized."
         };
       }
-      shellProjectMutation = isProjectMutatingShellCommand(command, execDecision.segments);
+      shellProjectMutation = isProjectMutatingShellCommand(command, execDecision.segments, ctx.cwd);
       configuredVerifierShell = Boolean(sessionTask && commandMatchesVerifyPlan(command, sessionTask.verifyCommands));
       const shellWriteCandidates = extractShellWritePathCandidates(command);
       shellMutationTargetBounded = shellWriteCandidates.length > 0;
@@ -4636,7 +4674,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
       const mutationForbidden = sessionTask?.trace.outcome === "pending"
         && (sessionTask.changeMode === "read-only" || sessionTask.mutationPolicy === "forbidden");
       const exactForbiddenTaskVerifier = mutationForbidden && sessionTask.changeMode === "source-change" && configuredVerifierShell;
-      if (mutationForbidden && !exactForbiddenTaskVerifier && !isReadOnlyTaskShellCommand(command, execDecision.segments)) {
+      if (mutationForbidden && !exactForbiddenTaskVerifier && !isReadOnlyTaskShellCommand(command, execDecision.segments, ctx.cwd)) {
         return {
           block: true,
           reason: `Task ${sessionTask.taskId} ${sessionTask.changeMode === "read-only" ? "is read-only; this shell command is not in the read-only inspection allowlist" : "forbids source mutation; this shell command is neither bounded inspection nor an exact configured verifier"}.`
@@ -4841,7 +4879,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
       && sessionTask.changeMode === "source-change"
       && (shellProjectMutation || configuredVerifierShell)
     ) {
-      runtimeState.rememberShellMutationSnapshot(ctx, event.toolName, event.input);
+      runtimeState.rememberShellMutationSnapshot(ctx, event.toolName, event.input, event.toolCallId);
     }
     }
   });
@@ -4863,6 +4901,8 @@ export default function piagentGuard(pi: ExtensionAPI) {
     createTaskRunId, crypto, currentSessionName, defaultRolePolicy, defaultWorkPlan, digestJson,
     dynamicToolsEnabled, effectiveProtectedPaths, emitRuntimeMessage, ensureContextIndexV2, estimateContextTokens,
     evaluateExecPolicy, evaluateModelRoute, evaluateRetrievalRoute, evaluateRuntimeSolver, evaluateTaskGate, evaluateToolPolicy, execPolicyConfig,
+    prepareIndependentAcceptance: (ctx: ExtensionContext, task: TaskContract, response?: { origin: "assistant"; bytes: string }) =>
+      independentAcceptance.prepare(ctx, task, response),
     extensionDir, externalActionPolicyConfig, extractDocument, finalGateConfig, findMatchingObservedBashResult,
     formatContextPreflight, formatCount, formatLiveTaskStatus, formatPercent, formatTechOptionsText, formatTechSelectionSummary,
     formatToolResultCaptureStatus, formatUsageSnapshot, fs, hasGitEvidenceRoot, hasOperatorSessionName, helpersMode,
@@ -4880,7 +4920,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
     safeTaskId, searchContextIndex, searchContextIndexV2, searchMemoryFiles, selectRuntimeAction,
     selectValueFromUi, selectVerificationPlan, semanticCompactionInstructions, sendWorkflowFollowUp, setPermissionOverrideForContext,
     semanticRepairCompletionBlock: (cwd: string, taskRunId: string) => semanticRepairRuntime.completionBlock(cwd, taskRunId),
-    freshRequestParts, shellArg, shortTaskLabel, solverShadow, summarizeAttempt, taskChangedFileEvidence,
+    freshRequestParts, shellArg, shortTaskLabel, solverShadow, summarizeAttempt, taskAcceptanceEvidenceFiles, taskChangedFileEvidence,
     techContextDirPath, techContextFilePath, techContextRelativePath, techOptionById, techStackPath,
     telemetry, toolRegistryConfig, trajectoryRuntime, uniqueStrings, usageExactCommands,
     validTaskScopePattern, validateNewWorkPlan, verifierCommandInstructions, verifyProjectCapabilityState, workingTreeEvidenceDigest,
@@ -4911,9 +4951,10 @@ export default function piagentGuard(pi: ExtensionAPI) {
 
   function commandArgs(raw: string): { action: string; rest: string; tokens: string[] } {
     const trimmed = String(raw ?? "").trim();
-    const tokens = trimmed.split(/\s+/).filter(Boolean);
-    const action = (tokens.shift() ?? "").toLowerCase();
-    return { action, rest: tokens.join(" "), tokens };
+    const match = /^(\S+)(?:\s+([\s\S]*))?$/.exec(trimmed);
+    const action = (match?.[1] ?? "").toLowerCase();
+    const rest = match?.[2] ?? "";
+    return { action, rest, tokens: rest.split(/\s+/).filter(Boolean) };
   }
 
   function shellArg(value: string): string {
@@ -4945,6 +4986,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
   }
 
   registerPermissionCommands(pi, registrationDeps);
+  registerFastModeCommand(pi, serviceTierRuntime);
   const profileCommandApi = registerProfileCommands(pi, registrationDeps);
   registerMemoryMcpCommands(pi, registrationDeps);
   const contextCommandApi = registerContextCommands(pi, registrationDeps);