@piagent/platform 1.5.5 → 1.6.1

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

@@ -67,7 +67,7 @@ import {
 } from "./context-index-policy.js";
 import {
   DEFAULT_MAX_TASK_ATTEMPTS, activeSessionTask, bindSessionTask, createTaskRunId, hasGitEvidenceRoot, listTaskContracts,
-  pathWithinChangeEvidenceRoot, priorTaskAttempts, repositoryFileManifest, resolveTaskContract, safeTaskId, summarizeAttempt, taskContractValidationErrors, taskDigestMigrationArchiveStatus,
+  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";
@@ -84,12 +84,14 @@ import {
   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 { appendJsonlBounded } from "./state-retention.js";
 import { ensurePrivateStateDirectory, resolveLocalStatePath } from "./local-state-path.js";
+import { hasDurableContextEvidence } from "./context-evidence.js";
 import { piApprovalBroker, type ApprovalActionDraft, type ApprovalUnavailableFallback } from "../runtime/inspection/approval-broker.ts";
 import { inspectTaskControlState } from "../runtime/inspection/task-control-journal.ts";
 import { createSourceMutationGuardBindings } from "../runtime/policy/source-mutation-guard-binding.ts";
@@ -108,6 +110,7 @@ import {
 } from "../runtime/session/tool-result-compaction.ts";
 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 {
   PIAGENT_TOOL_GROUPS,
   PIAGENT_TOOL_NAMES,
@@ -121,6 +124,7 @@ import {
   automaticReviewLenses,
   automaticReadOnlyTaskScope,
   automaticTaskIntakeMode,
+  automaticTaskMutationPolicy,
   automaticTaskRiskLane,
   automaticTaskScope,
   resolveTaskScopePatterns,
@@ -137,6 +141,8 @@ import { registerToolResultHook } from "../runtime/hooks/tool-result-hook.ts";
 import { readRuntimeVersionMetadata, RuntimeSnapshotCapture } from "../runtime/model/runtime-snapshot.ts";
 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 { 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";
@@ -147,6 +153,7 @@ import { SolverShadowRuntime, solverModeFromEnvironment } from "../runtime/solve
 import { observeTrajectorySync } from "../runtime/trajectory/trajectory-observability.ts";
 import { TrajectoryRuntime } from "../runtime/trajectory/trajectory-runtime.ts";
 import { PhaseToolRuntime, phaseToolModeFromEnvironment } from "../runtime/tools/phase-tool-runtime.ts";
+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";
@@ -155,11 +162,14 @@ import { inspectTaskResumeState } from "../runtime/recovery/resume-state.ts";
 import { SemanticRepairRuntime } from "../runtime/recovery/semantic-repair-runtime.ts";
 import { defaultRolePolicy } from "../runtime/orchestration/role-policy.ts";
 import { helpersMode } from "../runtime/orchestration/helper-lifecycle.ts";
+import { evaluateDirectSubagentDispatch, recordDirectSubagentResult, reserveDirectSubagentDispatch, taskHelperUsageMode } from "../runtime/orchestration/subagent-tool-policy.ts";
 import { buildLiveTaskStatus, formatLiveTaskStatus } from "../runtime/product/operator-projections.ts";
 import { buildTaskEfficiencyMetrics } from "../runtime/product/efficiency-metrics.ts";
 import { performanceReviewToolDecision, performanceReviewToolKind } from "../runtime/quality/performance-assurance.ts";
 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 { 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";
 import { registerPiagentStatusCommand } from "../runtime/registration/runtime-model-status.ts";
@@ -226,6 +236,7 @@ type TaskStartParameters = {
   riskLane: "tiny" | "normal" | "high-risk";
   intakeMode?: "model" | "runtime";
   changeMode?: "source-change" | "read-only";
+  mutationPolicy?: "required" | "forbidden";
   verifyGroup?: string;
   maxAttempts?: number;
   expectedOutput: string;
@@ -334,11 +345,11 @@ const DEFAULT_RUNTIME_POLICY: Required<RuntimePolicySettings> = {
 
 const DEFAULT_ORCHESTRATION_POLICY: ResolvedOrchestrationPolicy = {
   defaultMode: "solo-first",
-  maxConcurrentSubagents: 2,
+  maxConcurrentSubagents: 1,
   defaultReviewLenses: ["correctness", "tests", "scope"],
   roleModelGuidance: {
     planner: "Use the strongest available model for decomposition, architecture, risk, and acceptance criteria.",
-    worker: "Use the fastest reliable model for a bounded, already-planned single write set.",
+    worker: "Disabled by default. The parent model owns all implementation and mutation.",
     reviewer: "Use a model or thinking setting decorrelated from the worker when review quality matters.",
     watchdog: "Use a strong model only for final risk review, security, release, or high-impact changes."
   },
@@ -350,9 +361,9 @@ const DEFAULT_ORCHESTRATION_POLICY: ResolvedOrchestrationPolicy = {
     readBeforeTask: true
   },
   rules: [
-    "Default to one parent agent; do not start a swarm for ordinary implementation.",
-    "Use subagents only for bounded read-only scout, planning, review, or a single approved worker.",
-    "Parallel read-only review is allowed when the diff is non-trivial; parallel writers require explicit user approval and isolation.",
+    "Default to the parent model working directly; a helper is an exceptional token optimization, not a reasoning phase.",
+    "Use at most one fresh read-only helper only when runtime evidence proves at least two independent lanes and at least 30% projected net token savings.",
+    "Never delegate implementation, inherit parent history, retry a deterministic helper failure, or run parallel helpers/writers.",
     "Treat Field Guide memory as advisory; verify every durable fact against current repository files.",
     "Keep review lenses explicit so cheap review work catches drift before release."
   ]
@@ -379,174 +390,7 @@ 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>();
 
-// The policy used when `policies/base-policy.json` cannot be read. It runs in
-// exactly the case where something is already wrong, so it must never be the
-// looser of the two: this copy had drifted behind the file and silently dropped
-// `.pi/piagent-state/**` -- the guard's own state -- along with the `sudo ` and
-// `chmod -R 777` blocks. A missing policy file is a reason to be stricter, not a
-// quiet downgrade. `tests/policy-core.test.mjs` fails if this drifts again.
-const DEFAULT_POLICY: BasePolicy = {
-  protectedPaths: [".git/**", "**/auth.json", "**/.env", "**/.env.*", "**/node_modules/**", "**/dist/**", ".pi/piagent-state/**", ".pi/settings.json", ".pi/piagent-profile.json", ".pi/piagent-profile.lock.json", CONTEXT_INDEX_FILE],
-  shellProtectedPaths: [".git/**", "**/auth.json", "**/.env", "**/.env.*", ".pi/piagent-state/**", ".pi/settings.json", ".pi/piagent-profile.json", ".pi/piagent-profile.lock.json", CONTEXT_INDEX_FILE],
-  blockedCommandPatterns: ["rm -rf /", "rm -rf ~", "rm -rf $HOME", "git reset --hard", "git clean -fd", "sudo ", "chmod -R 777"],
-  requireConfirmationPatterns: ["deploy", "release", "publish", "migration", "gh pr merge", "git push"],
-  defaultRequiredContext: ["AGENTS.md", "README.md"],
-  permissionProfiles: {
-    defaultMode: "workspace-write",
-    allowedModes: ["read-only", "workspace-write", "trusted-full-access"]
-  },
-  execPolicy: {
-    defaultMode: "enforce",
-    bannedPrefixSuggestions: [
-      ["python"],
-      ["python3"],
-      ["node"],
-      ["node", "-e"],
-      ["bash"],
-      ["bash", "-lc"],
-      ["sh"],
-      ["sh", "-c"],
-      ["zsh"],
-      ["zsh", "-lc"],
-      ["git"],
-      ["sudo"],
-      ["env"]
-    ],
-    rules: [
-      {
-        id: "prompt-git-add-broad",
-        action: "prompt",
-        match: "regex",
-        value: "(?:^|\\s)git\\s+(?:-C\\s+\\S+\\s+)?add\\s+(?:(?:--all|-A)(?:\\s+(?:\\.|:/))?|--\\s+(?:\\.|:/)|(?:\\.|:/))(?:\\s|$)",
-        reason: "Broad git staging can include unrelated or sensitive changes; inspect git status/diff and confirm the exact scope first."
-      }
-    ]
-  },
-  contextBudget: {
-    defaultMode: "enforce",
-    maxContextFileChars: 50000,
-    maxMemoryFileChars: 20000,
-    maxManifestFiles: 80,
-    warnFragmentChars: 4000
-  },
-  toolRegistry: {
-    defaultMode: "advisory",
-    alwaysAllowedTools: [
-      "piagent_tools",
-      "piagent_context_engine",
-      "piagent_context",
-      "piagent_permission_status",
-      "piagent_exec_policy_check",
-      "piagent_context_budget",
-      "piagent_tool_policy_check",
-      "piagent_task_gate_check",
-      "piagent_usage_snapshot",
-      "piagent_orchestration_policy",
-      "piagent_memory_status",
-      "piagent_memory_note",
-      "piagent_memory_search",
-      "piagent_memory_citation_record",
-      "piagent_context_index_status",
-      "piagent_context_index_record",
-      "piagent_context_index_search",
-      "piagent_profile_options",
-      "piagent_profile_apply",
-      "piagent_profile_tech_options",
-      "piagent_profile_tech_apply",
-      "piagent_profile_tech_context_record",
-      "piagent_project_onboarding_record",
-      "piagent_task_start",
-      "piagent_task_progress",
-      "piagent_source_checkout",
-      "piagent_context_record",
-      "piagent_verify_record",
-      "piagent_trace_record"
-    ],
-    toolCapabilities: {
-      bash: ["shell"],
-      shell: ["shell"],
-      exec: ["shell"],
-      read: ["filesystem-readonly"],
-      grep: ["filesystem-readonly"],
-      find: ["filesystem-readonly"],
-      ls: ["filesystem-readonly"],
-      write: ["filesystem-write"],
-      edit: ["filesystem-write"],
-      browser: ["browser"],
-      github: ["github"]
-    }
-  },
-  externalActionPolicy: {
-    defaultMode: "enforce",
-    providerKeywords: [
-      "github",
-      "gitlab",
-      "bitbucket",
-      "vercel",
-      "netlify",
-      "cloudflare",
-      "aws",
-      "gcp",
-      "azure",
-      "slack",
-      "teams",
-      "jira",
-      "linear",
-      "notion",
-      "figma",
-      "stripe",
-      "supabase",
-      "firebase"
-    ],
-    writeVerbs: [
-      "add",
-      "approve",
-      "archive",
-      "assign",
-      "close",
-      "comment",
-      "create",
-      "delete",
-      "deploy",
-      "dispatch",
-      "merge",
-      "open",
-      "post",
-      "publish",
-      "push",
-      "release",
-      "remove",
-      "reopen",
-      "run",
-      "send",
-      "submit",
-      "trigger",
-      "update",
-      "upload",
-      "write"
-    ],
-    safeVerbs: [
-      "fetch",
-      "find",
-      "get",
-      "inspect",
-      "list",
-      "read",
-      "search",
-      "show",
-      "view"
-    ]
-  },
-  finalGate: {
-    defaultMode: "enforce",
-    requireTaskContract: true,
-    requireContextManifest: true,
-    requireVerifyEvidence: true,
-    requireTrace: true,
-    requirePassingVerify: true
-  },
-  orchestrationPolicy: DEFAULT_ORCHESTRATION_POLICY
-};
+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.
@@ -1007,7 +851,12 @@ function inspectPathInputsFromInput(
   const seen = new Set<string>();
   const walked = walkStringInputs(input, [], 0, includeFilesystemContentFields);
   for (const item of walked.items) {
-    const normalized = normalizeRelative(cwd, item.value);
+    const relative = normalizeRelative(cwd, item.value);
+    // `path.relative(root, root)` is the empty string. Treat that canonical
+    // project-root spelling as `.` so a capability such as `**/*` admits
+    // `ls .` and an absolute path equal to cwd. The empty candidate matched no
+    // scope and made fresh helpers unable to inspect even their own project.
+    const normalized = relative === "" ? "." : relative;
     if (normalized === undefined) continue;
     const key = `${item.field}\0${normalized}`;
     if (seen.has(key)) continue;
@@ -1117,6 +966,7 @@ function evaluatePathLikeToolAccess(
     forceScopeAware?: boolean;
     forceWrite?: boolean;
     allowAmbiguousFilesystemContentFields?: boolean;
+    sourceCheckoutReadRoots?: string[];
   } = {}
 ): { block: boolean; reason?: string } {
   const scopeAwareTool = options.forceScopeAware === true || ["read", "write", "edit", "grep", "find", "ls"].includes(toolName)
@@ -1158,9 +1008,13 @@ function evaluatePathLikeToolAccess(
   }
 
   for (const item of inspectedPaths) {
+    const fieldAccessMode = filesystemFieldAccessMode(toolName, item.field, writesFilesystem);
+    const sourceCheckoutReadRoot = fieldAccessMode === "read"
+      ? grantedSourceCheckoutRootForPath(cwd, item.path, options.sourceCheckoutReadRoots ?? [])
+      : undefined;
     if (scopeAwareTool && isFilesystemScopeField(item.field)) {
       const boundary = inspectRepositoryPathBoundary(cwd, item.path);
-      if (boundary.reason) return { block: true, reason: `Blocked ${toolName}: ${boundary.reason}` };
+      if (boundary.reason && !sourceCheckoutReadRoot) return { block: true, reason: `Blocked ${toolName}: ${boundary.reason}` };
     }
     const resolvedPath = resolveRepositoryPathCandidate(cwd, item.path);
     const readMatched = matchesProtectedPath(item.path, readProtectedPaths)
@@ -1172,7 +1026,6 @@ function evaluatePathLikeToolAccess(
       };
     }
 
-    const fieldAccessMode = filesystemFieldAccessMode(toolName, item.field, writesFilesystem);
     if (fieldAccessMode === "write") {
       const readOnlyMatched = matchesProtectedPath(item.path, readOnlyPaths)
         ?? (resolvedPath ? matchesProtectedPath(resolvedPath, readOnlyPaths) : undefined);
@@ -1196,7 +1049,8 @@ function evaluatePathLikeToolAccess(
           reason: `Blocked ${toolName} write outside resolved filesystem scope from ${item.field}: ${item.path}`
         };
       }
-    } else if (scopeAwareTool && filesystemRead && isFilesystemScopeField(item.field) && !matchesAnyPath(item.path, filesystemRead)) {
+    } else if (scopeAwareTool && filesystemRead && isFilesystemScopeField(item.field)
+      && !sourceCheckoutReadRoot && !matchesAnyPath(item.path, filesystemRead)) {
       return {
         block: true,
         reason: `Blocked ${toolName} read outside resolved filesystem scope from ${item.field}: ${item.path}`
@@ -1227,6 +1081,21 @@ function evaluatePathLikeToolAccess(
   return { block: false };
 }
 
+function grantedSourceCheckoutRootForPath(cwd: string, candidate: string, roots: string[]): string | undefined {
+  if (roots.length === 0) return undefined;
+  const absolute = path.resolve(cwd, normalizePathCandidate(candidate));
+  let canonical: string;
+  try {
+    canonical = fs.realpathSync.native(absolute);
+  } catch {
+    return undefined;
+  }
+  return roots.find((root) => {
+    const relative = path.relative(root, canonical);
+    return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+  });
+}
+
 function stateRoot(cwd: string): string {
   return path.join(cwd, ".pi", "piagent-state");
 }
@@ -1395,6 +1264,7 @@ function evaluatePermissionProfileToolAccess(
 function contextBudgetConfig(policy: BasePolicy): Required<ContextBudgetConfig> {
   return {
     defaultMode: policy.contextBudget?.defaultMode ?? DEFAULT_POLICY.contextBudget?.defaultMode ?? "enforce",
+    contextDeltaShadow: policy.contextBudget?.contextDeltaShadow ?? DEFAULT_POLICY.contextBudget?.contextDeltaShadow ?? "off",
     maxContextFileChars: policy.contextBudget?.maxContextFileChars ?? DEFAULT_POLICY.contextBudget?.maxContextFileChars ?? 50000,
     maxMemoryFileChars: policy.contextBudget?.maxMemoryFileChars ?? DEFAULT_POLICY.contextBudget?.maxMemoryFileChars ?? 20000,
     maxManifestFiles: policy.contextBudget?.maxManifestFiles ?? DEFAULT_POLICY.contextBudget?.maxManifestFiles ?? 80,
@@ -1503,7 +1373,7 @@ function resolveOrchestrationPolicy(profile: ProjectProfile, policy: BasePolicy)
   };
   return {
     defaultMode: normalizeOrchestrationMode(configured.defaultMode, defaultPolicy.defaultMode),
-    maxConcurrentSubagents: boundedInteger(configured.maxConcurrentSubagents, defaultPolicy.maxConcurrentSubagents, 0, 6),
+    maxConcurrentSubagents: Math.min(1, boundedInteger(configured.maxConcurrentSubagents, defaultPolicy.maxConcurrentSubagents, 0, 1)),
     defaultReviewLenses: normalizeReviewLenses(configured.defaultReviewLenses, defaultPolicy.defaultReviewLenses),
     roleModelGuidance,
     fieldGuide: {
@@ -1544,9 +1414,10 @@ function normalizeWorkPlanSteps(values: unknown): WorkPlanStep[] {
 function defaultWorkPlan(
   summary: string,
   riskLane: TaskContract["riskLane"],
-  changeMode: TaskContract["changeMode"]
+  changeMode: TaskContract["changeMode"],
+  mutationPolicy: NonNullable<TaskContract["mutationPolicy"]> = changeMode === "read-only" ? "forbidden" : "required"
 ): WorkPlanStep[] {
-  if (changeMode === "read-only") {
+  if (changeMode === "read-only" || mutationPolicy === "forbidden") {
     if (riskLane === "tiny") {
       return [{
         id: "scout",
@@ -1751,6 +1622,69 @@ function collectPatchTargetPaths(value: unknown, key = "", depth = 0): string[]
   return paths;
 }
 
+type ApplyPatchTargetInspection =
+  | { carrier: false; exactLocalExecutor: false; targets: [] }
+  | { carrier: true; exactLocalExecutor: boolean; targets: string[]; reason?: undefined }
+  | { carrier: true; exactLocalExecutor: boolean; targets: []; reason: string };
+
+function isApplyPatchToolName(toolName: string): boolean {
+  const tokens = new Set(actionTokens(toolName));
+  // Pi direct MCP tools are named <server-prefix>_<tool>, for example
+  // filesystem_apply_patch; they never carry an mcp__ prefix. Treat every
+  // apply+patch action carrier as this exact fail-closed protocol so a custom
+  // prefix cannot bypass target extraction.
+  return tokens.has("apply") && tokens.has("patch");
+}
+
+function inspectApplyPatchAuthorizationTargets(
+  toolName: string,
+  input: Record<string, unknown>
+): ApplyPatchTargetInspection {
+  let carrier = toolName;
+  let payload = input;
+  const exactLocalExecutor = toolName === "apply_patch";
+  if (normalizeActionToken(toolName) === "mcp") {
+    const proxyTool = typeof input.tool === "string" ? input.tool.trim() : "";
+    if (!isApplyPatchToolName(proxyTool)) return { carrier: false, exactLocalExecutor: false, targets: [] };
+    carrier = proxyTool;
+    if (typeof input.args !== "string" || input.args.length > MAX_MCP_PROXY_ARGS_CHARS) {
+      return { carrier: true, exactLocalExecutor: false, targets: [], reason: "MCP apply_patch args must be a bounded JSON object string" };
+    }
+    try {
+      const parsed = JSON.parse(input.args);
+      if (!isPlainRecord(parsed)) return { carrier: true, exactLocalExecutor: false, targets: [], reason: "MCP apply_patch args must decode to a JSON object" };
+      payload = parsed;
+    } catch {
+      return { carrier: true, exactLocalExecutor: false, targets: [], reason: "MCP apply_patch args must be valid JSON" };
+    }
+  }
+  if (!isApplyPatchToolName(carrier)) return { carrier: false, exactLocalExecutor: false, targets: [] };
+  const keys = Object.keys(payload);
+  if (keys.length !== 1 || keys[0] !== "patch" || typeof payload.patch !== "string") {
+    return { carrier: true, exactLocalExecutor, targets: [], reason: "apply_patch input must contain only one string field named patch" };
+  }
+  try {
+    return { carrier: true, exactLocalExecutor, targets: parseApplyPatchTargets(payload.patch) };
+  } catch (error) {
+    return {
+      carrier: true,
+      exactLocalExecutor,
+      targets: [],
+      reason: error instanceof Error ? error.message : "apply_patch target extraction failed"
+    };
+  }
+}
+
+function authorizationMutationTargetInspection(
+  cwd: string,
+  toolName: string,
+  input: Record<string, unknown>
+): { targets: string[]; patchCarrier: boolean; exactLocalPatchExecutor: boolean; reason?: string } {
+  const patch = inspectApplyPatchAuthorizationTargets(toolName, input);
+  if (patch.carrier) return { targets: patch.targets, patchCarrier: true, exactLocalPatchExecutor: patch.exactLocalExecutor, reason: patch.reason };
+  return { targets: taskMutationTargets(cwd, toolName, input), patchCarrier: false, exactLocalPatchExecutor: false };
+}
+
 function taskMutationIdentity(toolName: string, input: Record<string, unknown>): string {
   if (normalizeActionToken(toolName) !== "mcp") return toolName;
   const proxyTool = typeof input.tool === "string" ? input.tool.trim() : "";
@@ -1772,13 +1706,18 @@ function isReadOnlyTaskShellCommand(
   if (/[<>]|`|\$\(/.test(command)) {
     return false;
   }
-  const safeCommands = new Set(["pwd", "ls", "find", "rg", "grep", "cat", "sed", "head", "tail", "wc", "stat", "file", "test", "[", "which"]);
+  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";
@@ -1786,6 +1725,16 @@ function isReadOnlyTaskShellCommand(
   });
 }
 
+function shellTouchesGrantedSourceCheckout(cwd: string, command: string, roots: string[]): boolean {
+  if (roots.length === 0) return false;
+  for (const root of roots) {
+    const relative = path.relative(cwd, root).split(path.sep).join("/");
+    if (command.includes(root) || (relative && command.includes(relative))) return true;
+  }
+  return extractShellPathCandidates(command)
+    .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",
@@ -2102,7 +2051,7 @@ function flushObservedTaskContext(
   const task = activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined;
   if (!task || task.trace.outcome !== "pending") return task;
   const added = mergeObservedTaskContext(task, pendingContext, maxManifestFiles, redactText);
-  const lifecycle = task.changeMode === "read-only" && task.contextManifest.length > 0
+  const lifecycle = (task.changeMode === "read-only" || task.mutationPolicy === "forbidden") && hasDurableContextEvidence(task)
     ? applyRuntimeLifecycleObservation(task, "context-complete", nowIso())
     : { changed: false, mode: runtimeLifecycleMode(task) };
   if (added.length === 0 && !lifecycle.changed) return task;
@@ -2173,9 +2122,13 @@ function prepareToolInputForPolicy(
       return { input, reason: "MCP proxy args must be valid JSON" };
     }
     if (!isPlainRecord(parsed)) return { input, reason: "MCP proxy args must decode to a JSON object" };
-    const patchTargets = actionTokens(proxyTool).includes("patch")
-      ? collectPatchTargetPaths(parsed)
-      : [];
+    const exactPatch = inspectApplyPatchAuthorizationTargets(toolName, input);
+    if (exactPatch.carrier && exactPatch.reason) return { input, reason: exactPatch.reason };
+    const patchTargets = exactPatch.carrier
+      ? exactPatch.targets
+      : actionTokens(proxyTool).includes("patch")
+        ? collectPatchTargetPaths(parsed)
+        : [];
     policyInput = patchTargets.length > 0
       ? { ...input, proxyArgs: parsed, proxyPatchTargets: { paths: patchTargets } }
       : { ...input, proxyArgs: parsed };
@@ -3572,7 +3525,7 @@ function taskScopeIncludesPath(scope: string[], file: string): boolean {
 }
 
 function verifierCommandInstructions(commands: string[]): string[] {
-  return commands.map((command, index) => `Verifier ${index + 1} (run as its own shell call): ${command}`);
+  return commands.map((command, index) => `Verifier ${index + 1} (run as an exact standalone shell command): ${command}`);
 }
 
 function evaluateTaskGate(
@@ -3605,7 +3558,7 @@ function evaluateTaskGate(
   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 && task.contextManifest.length === 0) missing.push("context manifest");
+  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.verifyEvidence.some((evidence) => evidence.observed !== true)) {
     warnings.push("Unobserved verify evidence is ignored by the passing verify gate.");
@@ -3632,14 +3585,16 @@ function evaluateTaskGate(
     missing.push(`completed work plan (${incompleteSteps.map((step) => `${step.id}:${step.status}`).join(", ")})`);
   }
   const changedFileEvidence = taskChangedFileEvidence(cwd, task, currentDigests);
-  if (task.changeMode === "source-change" && task.trace.outcome === "completed") {
+  if (task.changeMode === "source-change" && task.trace.outcome === "completed" && task.mutationPolicy !== "forbidden") {
     if (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) missing.push(`changes within task scope (${changedFileEvidence.outsideScope.join(", ")})`);
+    if (changedFileEvidence.outsideScope.length > 0) {
+      warnings.push(`Task focus expanded beyond the initial scope (${changedFileEvidence.outsideScope.join(", ")}).`);
+    }
   }
-  if (task.changeMode === "read-only" && changedFileEvidence.expected.length > 0) {
-    missing.push(`read-only task has observed changes (${changedFileEvidence.expected.join(", ")})`);
+  if ((task.changeMode === "read-only" || task.mutationPolicy === "forbidden") && changedFileEvidence.expected.length > 0) {
+    missing.push(`mutation-forbidden task has observed changes (${changedFileEvidence.expected.join(", ")})`);
   }
   const acceptance = refreshAcceptanceReceipt(task, {
     cwd,
@@ -3647,9 +3602,11 @@ function evaluateTaskGate(
     currentWorkingTreeDigest
   });
   const semanticEnforcement = taskAuthorityDecision(task, "CAP-13", "block").allowed;
-  if (semanticEnforcement && acceptance.criticalMissing.length > 0) {
-    missing.push(`critical acceptance evidence (${acceptance.criticalMissing.map((criterion) => `${criterion.id}:${criterion.obligation}`).join(", ")})`);
-  }
+  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 acceptanceConflicts = acceptanceSemanticConflicts(task, {
     cwd,
     changedFiles: changedFileEvidence.expected
@@ -3657,7 +3614,11 @@ function evaluateTaskGate(
   if (semanticEnforcement && acceptanceConflicts.length > 0) {
     missing.push(`acceptance semantic conflicts (${acceptanceConflicts.join(", ")})`);
   }
-  const normalMissing = acceptance.missing.filter((criterion) => criterion.priority !== "critical");
+  const criticalIds = new Set(acceptance.criticalMissing.map((criterion) => criterion.id));
+  const normalMissing = acceptance.missing.filter((criterion) => !criticalIds.has(criterion.id));
+  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 (normalMissing.length > 0) {
     warnings.push(`Acceptance criteria pending evidence: ${normalMissing.map((criterion) => `${criterion.id}:${criterion.obligation}`).join(", ")}`);
@@ -3837,6 +3798,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
   const runtimeState = new RuntimeSessionState({
     maxObservedContext: contextBudgetConfig(policy).maxManifestFiles
   });
+  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);
@@ -3867,6 +3829,55 @@ export default function piagentGuard(pi: ExtensionAPI) {
   pi.on("thinking_level_select", (_event, ctx) => {
     modelSelectionProvenance.observeThinkingSelection(ctx.sessionManager.getSessionId());
   });
+  pi.on("before_provider_request", (event, ctx) => {
+    const normalized = normalizeOpenAiCodexReasoningPayload({
+      payload: event.payload,
+      provider: ctx.model?.provider,
+      modelId: ctx.model?.id,
+      hostThinkingLevel: pi.getThinkingLevel()
+    });
+    if (normalized.applicable) {
+      telemetry(ctx, {
+        event: "provider_request_reasoning",
+        hostThinkingLevel: normalized.hostThinkingLevel,
+        providerReasoningEffort: normalized.providerEffort,
+        expectedProviderReasoningEffort: normalized.expectedProviderEffort,
+        providerReasoningEffortMatches: normalized.providerEffort === normalized.expectedProviderEffort,
+        providerReasoningNormalized: normalized.changed,
+        providerReasoningReasonCode: normalized.reasonCode
+      });
+    }
+    const wire = buildOpenAiCodexWireFingerprint({
+      payload: normalized.changed ? normalized.payload : event.payload,
+      provider: ctx.model?.provider,
+      modelId: ctx.model?.id,
+      workingDirectory: ctx.cwd,
+      platformRoot: PLATFORM_ROOT
+    });
+    if (wire.applicable) {
+      telemetry(ctx, {
+        event: "provider_request_wire_surface",
+        state: wire.state,
+        reasonCode: wire.reasonCode,
+        providerModelId: wire.modelId,
+        instructionsHash: wire.instructionsHash,
+        baseInstructionsHash: wire.baseInstructionsHash,
+        instructionNormalization: wire.instructionNormalization,
+        instructionChars: wire.instructionChars,
+        orderedToolSurfaceHash: wire.orderedToolSurfaceHash,
+        providerToolCount: wire.toolCount,
+        deferredToolSurfaceHash: wire.deferredToolSurfaceHash,
+        deferredToolCount: wire.deferredToolCount,
+        deferredToolBatchCount: wire.deferredToolBatchCount,
+        providerReasoningEffort: wire.reasoningEffort,
+        providerTextVerbosity: wire.textVerbosity,
+        providerToolChoiceKind: wire.toolChoiceKind,
+        providerToolChoiceHash: wire.toolChoiceHash,
+        requestPrefixFingerprint: wire.requestPrefixFingerprint
+      });
+    }
+    return normalized.changed ? normalized.payload : undefined;
+  });
 
   function freshModelRouteBoundary(ctx: ExtensionContext): boolean {
     try {
@@ -3928,7 +3939,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
       let taskIdentity = runtimeState.taskIdentity(ctx);
       if (!taskIdentity) {
         const task = activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined;
-        if (task) {
+        if (task?.trace.outcome === "pending") {
           runtimeState.cacheTaskIdentity(ctx, task);
           taskIdentity = { taskId: task.taskId, taskRunId: task.taskRunId };
         }
@@ -4010,8 +4021,11 @@ export default function piagentGuard(pi: ExtensionAPI) {
       failed?.exitCode ?? 1
     );
     const trajectory = trajectoryRuntime.status(ctx.cwd, task.taskRunId);
-    const dependencyMutationAuthorized = task.scope.some((entry) => /(?:^|\/)(?:package(?:-lock)?\.json|pnpm-lock\.yaml|yarn\.lock|[^/]*(?:config|lock)[^/]*)$/i.test(entry));
-    return selectRecoveryDecision({
+    // Task scope is a retrieval/review hint, not filesystem authority. Recovery
+    // may update a dependency or config file when repository evidence requires
+    // it; protected-path and approval policy still run on the exact call.
+    const dependencyMutationAuthorized = true;
+    const selected = selectRecoveryDecision({
       featureEnabled: autoRecoveryEnabled && taskAuthorityDecision(task, "CAP-12", "model-turn").allowed,
       task: {
         taskId: task.taskId,
@@ -4030,6 +4044,9 @@ export default function piagentGuard(pi: ExtensionAPI) {
         : true,
       dependencyMutationAuthorized
     });
+    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;
   }
 
   function trajectoryRecoveryOptions(ctx: ExtensionContext, task: TaskContract, options: any): any {
@@ -4067,6 +4084,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
     resolveTaskAny: (cwd, reference) => resolveTaskContract(cwd, reference, undefined) as TaskContract | undefined,
     bindTask: bindSessionTask,
     writeTask,
+    appendTrace,
     capabilityState: (ctx) => verifyProjectCapabilityState(extensionDir, ctx.cwd, ctx.isProjectTrusted(), { allowRepin: true, forceFull: true, sessionId: ctx.sessionManager.getSessionId() }),
     permissionProfile: (ctx, profile) => resolvePermissionProfile(profile, policy, permissionOverrideFromContext(ctx)),
     legacyProjectWarning: legacyProjectStateWarning,
@@ -4080,7 +4098,8 @@ export default function piagentGuard(pi: ExtensionAPI) {
       const snapshot = workingTreeSnapshot(ctx.cwd) as Record<string, string>;
       const resume = workingTreeSnapshotHasUnavailableEvidence(snapshot)
         ? { openRepair: false }
-        : { openRepair: taskAuthorityDecision(task, "CAP-13", "block").allowed && semanticRepairRuntime.resume({
+        : { openRepair: (taskAuthorityDecision(task, "CAP-13", "block").allowed
+          || taskAuthorityDecision(task, "CAP-12", "mutate").allowed) && semanticRepairRuntime.resume({
             cwd: ctx.cwd,
             task,
             sessionId: ctx.sessionManager.getSessionId(),
@@ -4109,12 +4128,14 @@ export default function piagentGuard(pi: ExtensionAPI) {
     onAgentSettled: activityInspector.refresh,
     beforeShutdown: (ctx) => {
       sourceMutationGuardBindings.unbind(ctx);
+      editFreshnessGuard.clear(ctx);
       activityInspector.dispose(ctx);
       sessionCapabilityDigests.delete(`${ctx.cwd}\0${ctx.sessionManager.getSessionId()}`);
     }
   });
 
   registerInputHook(pi, {
+    state: runtimeState,
     boilerplateCollapseChars: BOILERPLATE_COLLAPSE_CHARS,
     activeTask: (ctx) => activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined, authorityPolicy: (ctx, task) => ensureTaskAuthorityResumePolicy(ctx.cwd, task, { authorityProfile: loadProfileFromContext(ctx).authorityProfile, environment: process.env }),
     readProtectedPaths: (ctx) => effectiveProtectedPaths(policy, loadProfileFromContext(ctx)).readProtectedPaths,
@@ -4141,6 +4162,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
   registerAgentStartHook(pi, {
     state: runtimeState,
     autoContextEnabled,
+    contextDeltaShadowMode: contextBudgetConfig(policy).contextDeltaShadow,
     activeTask: (ctx) => activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined,
     readProtectedPaths: (ctx) => effectiveProtectedPaths(policy, loadProfileFromContext(ctx)).readProtectedPaths,
     contextExcludePatterns: (ctx) => contextIndexExcludePatterns(policy, loadProfileFromContext(ctx)),
@@ -4168,7 +4190,10 @@ export default function piagentGuard(pi: ExtensionAPI) {
     completionProjection: completionTaskProjection,
     evaluateGate: (cwd, task, currentDigests, currentDigest) => {
       const gate = evaluateTaskGate(cwd, task, policy, { currentDigests, currentWorkingTreeDigest: currentDigest });
-      const repairBlock = taskAuthorityDecision(task, "CAP-13", "block").allowed ? semanticRepairRuntime.completionBlock(cwd, task.taskRunId) : undefined;
+      const repairBlock = (taskAuthorityDecision(task, "CAP-13", "block").allowed
+        || taskAuthorityDecision(task, "CAP-12", "mutate").allowed)
+        ? semanticRepairRuntime.completionBlock(cwd, task.taskRunId)
+        : undefined;
       return repairBlock ? { ...gate, decision: "fail", missing: [...new Set([...gate.missing, repairBlock])] } : gate;
     },
     writeTask,
@@ -4187,6 +4212,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
     state: runtimeState,
     activeTask: (ctx) => activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined,
     maxManifestFiles: contextBudgetConfig(policy).maxManifestFiles,
+    flushObservedTaskContext,
     readProtectedPaths: (ctx) => effectiveProtectedPaths(policy, loadProfileFromContext(ctx)).readProtectedPaths,
     recordObservedBash: (observed) => bashResults.record(observed),
     observedBashLedgerPath,
@@ -4200,9 +4226,42 @@ export default function piagentGuard(pi: ExtensionAPI) {
     telemetry,
     activity: recordActivity,
     now: nowIso,
+    recordSubagentResult: (ctx, event, result) => {
+      const task = activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined;
+      const written = recordDirectSubagentResult(task, event, result, {
+        now: nowIso,
+        persist: (candidate) => writeTask(ctx.cwd, candidate),
+        trace: (payload) => appendTrace(ctx.cwd, payload),
+        sessionTrace: (payload) => appendSessionTrace(pi, payload)
+      });
+      telemetry(ctx, {
+        event: "helper_result_classified",
+        recordedAt: nowIso(),
+        taskRunId: written?.taskRunId,
+        toolCallId: event.toolCallId,
+        spawned: result.spawned,
+        failed: result.failed,
+        disposition: result.disposition,
+        reasonCode: result.reasonCode,
+        calls: result.calls,
+        tokens: result.tokens
+      });
+    },
+    observeEditFreshness: (ctx, event, metadata) => {
+      if (!metadata.successful || !metadata.taskRunId) return;
+      const protectedPaths = effectiveProtectedPaths(policy, loadProfileFromContext(ctx)).readProtectedPaths;
+      const source = event.toolName === "read" ? "read" : ["edit", "write", "apply_patch"].includes(event.toolName) ? "mutation" : undefined;
+      const candidates = source === "read" && metadata.targetPath ? [metadata.targetPath] : source === "mutation" ? metadata.mutationTargets : [];
+      const safeTargets = candidates.filter((file) => !matchesProtectedPath(file, protectedPaths));
+      const observed = source ? editFreshnessGuard.observe(ctx, metadata.taskRunId, safeTargets, source, nowIso()) : [];
+      if (observed.length) telemetry(ctx, { event: "edit_freshness_snapshot_observed", taskRunId: metadata.taskRunId, source, paths: observed.map(redactText) });
+    },
     completeSemanticRepair: (ctx, event, metadata) => {
       const task = activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined;
-      return task && taskAuthorityDecision(task, "CAP-13", "mutate").allowed ? semanticRepairRuntime.complete(ctx, task, event, metadata) : undefined;
+      return task && (taskAuthorityDecision(task, "CAP-13", "mutate").allowed
+        || taskAuthorityDecision(task, "CAP-12", "mutate").allowed)
+        ? semanticRepairRuntime.complete(ctx, task, event, metadata)
+        : undefined;
     },
     syncTrajectory: (ctx, contextObserved) => {
       const task = activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined;
@@ -4216,10 +4275,51 @@ export default function piagentGuard(pi: ExtensionAPI) {
     telemetry,
     activity: recordActivity,
     beforeAuthorize: (event, ctx) => {
-      if (!["edit", "write", "apply_patch"].includes(event.toolName)) return;
+      const toolInput = isPlainRecord(event.input) ? event.input : {};
       const task = activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined;
+      const helperPreflight = evaluateDirectSubagentDispatch({
+        toolName: event.toolName,
+        toolInput,
+        cwd: ctx.cwd,
+        helpersMode: task ? taskHelperUsageMode(task) : helpersMode(),
+        taskPending: task?.trace.outcome === "pending",
+        dispatchAuthority: Boolean(task && taskAuthorityDecision(task, "CAP-14", "dispatch").allowed),
+        durableSubagentState: task?.orchestration?.subagents
+      });
+      if (helperPreflight.applicable && helperPreflight.dispatch && !helperPreflight.allowed) {
+        telemetry(ctx, {
+          event: "helper_dispatch_blocked",
+          recordedAt: nowIso(),
+          taskRunId: task?.taskRunId,
+          toolCallId: event.toolCallId,
+          reasonCode: helperPreflight.reasonCode,
+          role: helperPreflight.role,
+          requestCount: helperPreflight.requestCount
+        });
+        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[] });
+      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;
+      }
+      const targetInspection = authorizationMutationTargetInspection(ctx.cwd, event.toolName, toolInput);
+      if (targetInspection.reason) return { block: true, reason: `Blocked ${event.toolName}: ${targetInspection.reason}.` };
+      if (task?.trace.outcome === "pending" && task.changeMode === "source-change" && (event.toolName === "edit" || targetInspection.exactLocalPatchExecutor)) {
+        const freshness = editFreshnessGuard.evaluate(ctx, task.taskRunId, targetInspection.targets);
+        if (freshness.decision === "stale") {
+          telemetry(ctx, { event: "edit_freshness_stale", taskRunId: task.taskRunId, toolCallId: event.toolCallId, enforce: freshness.enforce, paths: freshness.stalePaths.map(redactText) });
+          if (freshness.enforce) return { block: true, reason: `Blocked ${event.toolName}: the previously observed source snapshot is stale for ${freshness.stalePaths.map(redactText).join(", ")}. Reread the affected file once; no patch hunk was started.` };
+        }
+      }
+      if (!["edit", "write"].includes(event.toolName) && !targetInspection.exactLocalPatchExecutor) return;
       if (!task || task.trace.outcome !== "pending" || task.changeMode !== "source-change") return;
-      if (!taskAuthorityDecision(task, "CAP-13", "mutate").allowed) return;
+      const semanticRepairEnabled = taskAuthorityDecision(task, "CAP-13", "mutate").allowed;
+      const semanticRepairExactlyOff = !taskAuthorityDecision(task, "CAP-13", "observe").allowed;
+      const boundedRecoveryEnabled = autoRecoveryEnabled
+        && taskAuthorityDecision(task, "CAP-09", "block").allowed
+        && taskAuthorityDecision(task, "CAP-12", "mutate").allowed
+        && semanticRepairExactlyOff;
+      if (!semanticRepairEnabled && !boundedRecoveryEnabled) return;
       const phase = trajectoryRuntime.status(ctx.cwd, task.taskRunId);
       if (!phase.enforcementSafe || !["verify", "review"].includes(String(phase.phase))) return;
 
@@ -4227,16 +4327,40 @@ export default function piagentGuard(pi: ExtensionAPI) {
       if (workingTreeSnapshotHasUnavailableEvidence(currentSnapshot)) return;
       const currentDigest = workingTreeEvidenceDigest(currentSnapshot);
       const expectedReviewPaths = taskDeltaFilesFromSnapshot(task, currentSnapshot);
-      const toolInput = isPlainRecord(event.input) ? event.input : {};
-      const targets = taskMutationTargets(ctx.cwd, event.toolName, toolInput);
-      const boundedInScopeMutation = targets.length > 0
-        && targets.every((file) => taskScopeIncludesPath(task.scope, file));
+      const targets = targetInspection.targets;
+      const boundedTargetMutation = targets.length > 0;
+      const verifierCurrent = allVerifyCommandsPassCurrentTree(task, currentDigest);
 
-      if (phase.phase === "verify" && boundedInScopeMutation && semanticRepairRuntime.prepare({
+      if (phase.phase === "verify" && boundedTargetMutation && semanticRepairEnabled && semanticRepairRuntime.prepare({
         ctx, task, event, currentDigest, currentDeltaPaths: expectedReviewPaths, targetPaths: targets,
-        verifierCurrent: allVerifyCommandsPassCurrentTree(task, currentDigest)
+        verifierCurrent
       })) return;
 
+      // A public verifier can pass before every explicit user criterion is
+      // covered. CAP-12 therefore reserves one exact structured call when the
+      // model catches its own omission in the same task/run/session. The call
+      // still traverses every normal authorization check; verify -> repair is
+      // committed only by the tool-result hook after a successful tree change.
+      if (phase.phase === "verify" && boundedRecoveryEnabled && verifierCurrent && boundedTargetMutation) {
+        const authoredFileDigests = runtimeState.successfulModelMutationDigests(
+          { taskId: task.taskId, taskRunId: task.taskRunId, sessionId: task.sessionId },
+          currentSnapshot
+        );
+        if (semanticRepairRuntime.prepareBoundedRecovery({
+          ctx,
+          task,
+          event,
+          currentDigest,
+          currentDeltaPaths: expectedReviewPaths,
+          observedChangedPaths: task.observedChangedFiles,
+          authoredFileDigests,
+          targetPaths: targets,
+          verifierCurrent
+        })) return;
+      }
+
+      if (!semanticRepairEnabled) return;
+
       let checkpoint = runtimeState.performanceReviewCheckpoint(task.taskRunId);
       const checkpointReady = checkpoint?.workingTreeDigest === currentDigest
         && checkpoint.reviewSatisfied
@@ -4265,7 +4389,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
         return reviewDecision;
       }
 
-      if (targets.length === 0 || targets.some((file) => !taskScopeIncludesPath(task.scope, file))) return;
+      if (targets.length === 0) return;
       const result = trajectoryRuntime.sync(ctx.cwd, ctx.sessionManager.getSessionId(), task, {
         sourceHook: "tool-call",
         recoveryRequested: true,
@@ -4286,12 +4410,12 @@ export default function piagentGuard(pi: ExtensionAPI) {
       const currentDigest = workingTreeEvidenceDigest(workingTreeSnapshot(ctx.cwd) as Record<string, string>);
       const phase = trajectoryRuntime.status(ctx.cwd, task.taskRunId);
       const toolInput = isPlainRecord(event.input) ? event.input : {};
-      const targets = taskMutationTargets(ctx.cwd, event.toolName, toolInput);
-      if (["edit", "write", "apply_patch"].includes(event.toolName) && (
-        targets.length === 0 || targets.some((file) => !taskScopeIncludesPath(task.scope, file))
-      )) {
+      const targetInspection = authorizationMutationTargetInspection(ctx.cwd, event.toolName, toolInput);
+      if (targetInspection.reason) return { block: true, reason: `Blocked ${event.toolName}: ${targetInspection.reason}.` };
+      const targets = targetInspection.targets;
+      if ((["edit", "write"].includes(event.toolName) || targetInspection.patchCarrier) && targets.length === 0) {
         runtimeState.denyPerformanceReviewTool(task.taskRunId);
-        return { block: true, reason: `Task ${task.taskId} semantic repair must stay inside its declared task scope.` };
+        return { block: true, reason: `Task ${task.taskId} semantic repair requires an exact statically bounded target.` };
       }
       const reviewDecision = performanceReviewToolDecision({
         toolName: event.toolName,
@@ -4319,6 +4443,30 @@ export default function piagentGuard(pi: ExtensionAPI) {
     },
     afterAuthorized: (event, ctx, metadata) => {
       const task = activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined;
+      const helperPreflight = evaluateDirectSubagentDispatch({
+        toolName: event.toolName,
+        toolInput: event.input,
+        cwd: ctx.cwd,
+        helpersMode: task ? taskHelperUsageMode(task) : helpersMode(),
+        taskPending: task?.trace.outcome === "pending",
+        dispatchAuthority: Boolean(task && taskAuthorityDecision(task, "CAP-14", "dispatch").allowed),
+        durableSubagentState: task?.orchestration?.subagents
+      });
+      if (helperPreflight.applicable && helperPreflight.dispatch && helperPreflight.allowed) {
+        const reserved = reserveDirectSubagentDispatch(task, metadata.toolCallId, {
+          now: nowIso,
+          persist: (candidate) => writeTask(ctx.cwd, candidate),
+          trace: (payload) => appendTrace(ctx.cwd, payload)
+        });
+        telemetry(ctx, {
+          event: "helper_dispatch_reserved",
+          recordedAt: nowIso(),
+          taskRunId: reserved?.taskRunId,
+          toolCallId: metadata.toolCallId,
+          role: helperPreflight.role,
+          requestCount: helperPreflight.requestCount
+        });
+      }
       if (task?.trace.outcome === "pending") {
         const snapshot = workingTreeSnapshot(ctx.cwd) as Record<string, string>;
         const currentDigest = workingTreeEvidenceDigest(snapshot);
@@ -4361,6 +4509,11 @@ export default function piagentGuard(pi: ExtensionAPI) {
     authorize: async (event, ctx) => {
     const preTask = activeSessionTask(ctx.cwd, ctx.sessionManager.getSessionId()) as TaskContract | undefined;
     const preInput = isPlainRecord(event.input) ? event.input : {};
+    const authorizationTargetInspection = authorizationMutationTargetInspection(ctx.cwd, event.toolName, preInput);
+    if (authorizationTargetInspection.reason) {
+      return { block: true, reason: `Blocked ${event.toolName}: ${authorizationTargetInspection.reason}.` };
+    }
+    const authorizationTargets = authorizationTargetInspection.targets;
     const preSnapshot = preTask ? workingTreeSnapshot(ctx.cwd) as Record<string, string> : undefined;
     const reservedFirstCall = Boolean(preTask && preSnapshot && !workingTreeSnapshotHasUnavailableEvidence(preSnapshot) && semanticRepairRuntime.reservedCallMatches({
       cwd: ctx.cwd,
@@ -4369,7 +4522,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
       toolCallId: String(event.toolCallId),
       toolName: event.toolName,
       currentDigest: workingTreeEvidenceDigest(preSnapshot),
-      targetPaths: taskMutationTargets(ctx.cwd, event.toolName, preInput)
+      targetPaths: authorizationTargets
     }));
     const phaseDecision = reservedFirstCall || (preTask?.workingTreeDigestMigration?.status === "verification-refresh-required" && SHELL_TOOL_NAMES.has(event.toolName)) ? undefined : phaseToolRuntime.toolDecision(ctx, event.toolName);
     if (phaseDecision) return phaseDecision;
@@ -4427,10 +4580,11 @@ export default function piagentGuard(pi: ExtensionAPI) {
     const taskContractRequired = governedTaskProfile
       && runtime.finalGate === "enforce"
       && finalGateConfig(policy).requireTaskContract;
-    if (sessionTask?.trace.outcome === "pending" && sessionTask.changeMode === "read-only" && !SHELL_TOOL_NAMES.has(event.toolName) && isTaskMutationTool(event.toolName, toolInput)) {
+    if (sessionTask?.trace.outcome === "pending" && (sessionTask.changeMode === "read-only" || sessionTask.mutationPolicy === "forbidden")
+      && !SHELL_TOOL_NAMES.has(event.toolName) && isTaskMutationTool(event.toolName, toolInput)) {
       return {
         block: true,
-        reason: `Task ${sessionTask.taskId} is read-only; ${event.toolName} cannot mutate project or external state in this task. Start a source-change task for implementation.`
+        reason: `Task ${sessionTask.taskId} ${sessionTask.changeMode === "read-only" ? "is read-only" : "forbids source mutation"}; ${event.toolName} cannot mutate project or external state in this task. Start a mutation-required source task for implementation.`
       };
     }
     const preparedInput = prepareToolInputForPolicy(event.toolName, toolInput, policy);
@@ -4460,6 +4614,12 @@ export default function piagentGuard(pi: ExtensionAPI) {
       const execDecision = evaluateExecPolicy(command, profile, policy);
       authorizedShellCommand = command;
       authorizedShellSegments = execDecision.segments;
+      if (shellTouchesGrantedSourceCheckout(ctx.cwd, command, runtimeState.sourceCheckoutReadRoots(ctx))) {
+        return {
+          block: true,
+          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);
       configuredVerifierShell = Boolean(sessionTask && commandMatchesVerifyPlan(command, sessionTask.verifyCommands));
       const shellWriteCandidates = extractShellWritePathCandidates(command);
@@ -4473,10 +4633,13 @@ export default function piagentGuard(pi: ExtensionAPI) {
           && !candidate.startsWith("../")
           && !candidate.startsWith(".pi/piagent-state/")
         ));
-      if (sessionTask?.trace.outcome === "pending" && sessionTask.changeMode === "read-only" && !isReadOnlyTaskShellCommand(command, execDecision.segments)) {
+      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)) {
         return {
           block: true,
-          reason: `Task ${sessionTask.taskId} is read-only; this shell command is not in the read-only inspection allowlist.`
+          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"}.`
         };
       }
       if (execDecision.mode !== "off" && execDecision.decision === "forbid") {
@@ -4533,19 +4696,23 @@ export default function piagentGuard(pi: ExtensionAPI) {
     // Shell inputs need command grammar, not field-by-field path guessing: an
     // exclusion selector in `args` is not an accessed path. The semantic shell
     // checks above already inspect the normalized command, including redirects.
+    const policyPathInput = authorizationTargetInspection.patchCarrier
+      ? { paths: authorizationTargets }
+      : preparedInput.input;
     const pathDecision = SHELL_TOOL_NAMES.has(event.toolName) ? { block: false, reason: undefined } : evaluatePathLikeToolAccess(
       ctx.cwd,
       preparedInput.proxyToolName ?? event.toolName,
-      preparedInput.input,
+      policyPathInput,
       pathPolicy.writeProtectedPaths,
       pathPolicy.readProtectedPaths,
       pathPolicy.readOnlyPaths,
       permissionProfile.mode === "trusted-full-access" ? undefined : capabilityState.filesystemRead,
       permissionProfile.mode === "trusted-full-access" ? undefined : capabilityState.filesystemWrite,
       {
-        forceScopeAware: Boolean(preparedInput.proxyToolName),
-        forceWrite: preparedInput.proxyAction?.decision === "confirm",
-        allowAmbiguousFilesystemContentFields: !usesKnownExternalProvider && !isPiagentTool(event.toolName)
+        forceScopeAware: authorizationTargetInspection.patchCarrier || Boolean(preparedInput.proxyToolName),
+        forceWrite: authorizationTargetInspection.patchCarrier || preparedInput.proxyAction?.decision === "confirm",
+        allowAmbiguousFilesystemContentFields: !usesKnownExternalProvider && !isPiagentTool(event.toolName),
+        sourceCheckoutReadRoots: runtimeState.sourceCheckoutReadRoots(ctx)
       }
     );
     if (pathDecision.block) {
@@ -4573,7 +4740,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
 
     const mutationTargets = SHELL_TOOL_NAMES.has(event.toolName)
       ? shellMutationTargets
-      : taskMutationTargets(ctx.cwd, event.toolName, toolInput);
+      : authorizationTargets;
     const directProjectMutation = !SHELL_TOOL_NAMES.has(event.toolName) && (
       WRITE_TOOL_NAMES.has(event.toolName)
       || mutationTargets.length > 0
@@ -4597,7 +4764,9 @@ export default function piagentGuard(pi: ExtensionAPI) {
           opaqueCarrier: semanticOpaqueCarrier,
           targetExtractionComplete: SHELL_TOOL_NAMES.has(event.toolName)
             ? !shellHasOpaqueWritePrimitive(authorizedShellCommand)
-            : !semanticOpaqueCarrier && preparedInput.proxyShellCarrier !== true,
+            : authorizationTargetInspection.patchCarrier
+              ? authorizationTargetInspection.exactLocalPatchExecutor
+              : !semanticOpaqueCarrier && preparedInput.proxyShellCarrier !== true,
           recordedAt: nowIso()
         })
       : { handled: false, allowed: false, bypassPhase: false };
@@ -4629,37 +4798,25 @@ export default function piagentGuard(pi: ExtensionAPI) {
           + " Call `piagent_task_start` once with explicit project-relative scope, then retry."
       };
     }
-    if (sessionTask?.trace.outcome === "pending" && sessionTask.changeMode === "source-change") {
-      if (
-        shellProjectMutation
-        && opaqueShellMutationNeedsBoundedTarget(authorizedShellCommand, authorizedShellSegments)
-        && !shellMutationTargetBounded
-        && !configuredVerifierShell
-      ) {
-        return {
-          block: true,
-          reason: `Task ${sessionTask.taskId} cannot run an opaque shell mutation whose write target is not statically bounded. Use edit/write/apply_patch, an explicit in-scope redirection, or the exact configured verifier.`
-        };
-      }
-      const outsideScope = mutationTargets.filter((file) => !taskScopeIncludesPath(sessionTask.scope, file));
-      if (outsideScope.length > 0) {
-        return {
-          block: true,
-          reason: `Task ${sessionTask.taskId} cannot mutate paths outside its declared scope: ${outsideScope.join(", ")}.`
-        };
-      }
-      const outsideEvidenceRoot = mutationTargets.filter((file) => !pathWithinChangeEvidenceRoot(ctx.cwd, file));
-      if (outsideEvidenceRoot.length > 0) {
-        return {
-          block: true,
-          reason: `Task ${sessionTask.taskId} cannot mutate paths outside a change evidence root: ${outsideEvidenceRoot.join(", ")}. In a parent workspace with separate repos, write under a child repo or a scoped workspace directory such as plans/**.`
-        };
-      }
+    if (
+      sessionTask?.trace.outcome === "pending"
+      && sessionTask.changeMode === "source-change"
+      && shellProjectMutation
+      && opaqueShellMutationNeedsBoundedTarget(authorizedShellCommand, authorizedShellSegments)
+      && !shellMutationTargetBounded
+      && !configuredVerifierShell
+    ) {
+      return {
+        block: true,
+        reason: `Task ${sessionTask.taskId} cannot run an opaque shell mutation whose write target is not statically bounded. Use edit/write/apply_patch, an explicit project-local redirection, or the exact configured verifier.`
+      };
     }
-    if (runtime.contextBudget !== "off" && ["write", "edit"].includes(event.toolName)) {
-      const relativePath = extractLikelyPathFromInput(ctx.cwd, event.input as Record<string, unknown>);
-      if (relativePath) {
-        const budget = contextBudgetConfig(policy);
+    if (runtime.contextBudget !== "off" && (["write", "edit"].includes(event.toolName) || authorizationTargetInspection.patchCarrier)) {
+      const budgetTargets = authorizationTargetInspection.patchCarrier
+        ? authorizationTargets
+        : [extractLikelyPathFromInput(ctx.cwd, preInput)].filter((item): item is string => Boolean(item));
+      const budget = contextBudgetConfig(policy);
+      for (const relativePath of budgetTargets) {
         const stats = candidateFileBudget(ctx.cwd, relativePath, budget);
         if (runtime.contextBudget === "enforce" && stats.exists && stats.overLimit) {
           return { block: true, reason: `Context budget blocked editing large file ${relativePath}: ${stats.chars} chars > ${budget.maxContextFileChars}` };
@@ -4688,13 +4845,16 @@ export default function piagentGuard(pi: ExtensionAPI) {
     }
     }
   });
+  // Register only after authorization is live. The same-name override is intentional:
+  // guard target parsing, provenance, and atomicity require this exact tool contract.
+  registerApplyPatchTool(pi, Type);
   const registrationDeps = {
     CONTEXT_INDEX_EDGE_KINDS, CONTEXT_INDEX_NODE_KINDS, DEFAULT_MAX_TASK_ATTEMPTS, FRESH_COMMAND_ACTIONS, FRESH_COMMAND_HELP,
     ONBOARDING_COMMAND_ACTIONS, ORCHESTRATION_ROLES, PIAGENT_TOOL_NAMES, READ_ONLY_TOOL_NAMES, REVIEW_LENSES,
     StringEnum, TECH_STACK_MANIFEST_FILE, TOOL_RESULT_CAPTURE_MAX_CHARS, TOOL_RESULT_COMPACT_CHAR_THRESHOLD, TOOL_RESULT_COMPACT_LINE_THRESHOLD,
     TOOL_RESULT_PREVIEW_MAX_CHARS, Type, WORKFLOW_COMMAND_EXCLUSIONS, activateToolGroups, activeSessionTask,
     activeTaskToolGroups, allVerifyCommandsPassCurrentTree, appendMemoryNote, appendSessionTrace, appendTrace,
-    acceptanceBaselineGuidance, acceptanceProofGuidance, applyAcceptanceRecoveryProvenance, applyRuntimeLifecycleObservation, automaticAcceptanceCriteria, automaticReadOnlyTaskScope, automaticReviewLenses, automaticTaskIntakeMode, automaticTaskRiskLane, automaticTaskScope,
+    acceptanceBaselineGuidance, acceptanceLanguageAdapterForPath, acceptanceProofGuidance, applyAcceptanceRecoveryProvenance, applyRuntimeLifecycleObservation, automaticAcceptanceCriteria, automaticReadOnlyTaskScope, automaticReviewLenses, automaticTaskIntakeMode, automaticTaskMutationPolicy, automaticTaskRiskLane, automaticTaskScope,
     bashResults, bindSessionTask, buildAcceptanceReceipt, buildContextEfficiencyReport, buildContextIndexStatus, buildLiveTaskStatus, buildTaskEfficiencyMetrics,
     buildContextIndexV2, buildContextPack, buildContextPreflight, buildProfileOptions, buildProfileTechOptions,
     buildTestImpact, buildUsageSnapshot, candidateFileBudget, checkoutReferenceRepo, classifyContextTask,
@@ -4706,7 +4866,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
     extensionDir, externalActionPolicyConfig, extractDocument, finalGateConfig, findMatchingObservedBashResult,
     formatContextPreflight, formatCount, formatLiveTaskStatus, formatPercent, formatTechOptionsText, formatTechSelectionSummary,
     formatToolResultCaptureStatus, formatUsageSnapshot, fs, hasGitEvidenceRoot, hasOperatorSessionName, helpersMode,
-    loadProfileFromContext, matchesAnyPath, matchesProtectedPath, mcpActions, mcpApprovalCache,
+    isAcceptanceTestPath, loadProfileFromContext, matchesAnyPath, matchesProtectedPath, mcpActions, mcpApprovalCache,
     memoryHandbookPath, memoryLocalDir, memorySummaryPath, normalizeProjectProfileName, normalizeRelative,
     normalizeReviewLenses, normalizeTechSelections, normalizeWorkPlanSteps, nowIso, observedBashLedgerPath,
     path, permissionOverrideFromContext, permissionProfilesConfig, policy, prefixCompletions,
@@ -4724,7 +4884,7 @@ export default function piagentGuard(pi: ExtensionAPI) {
     techContextDirPath, techContextFilePath, techContextRelativePath, techOptionById, techStackPath,
     telemetry, toolRegistryConfig, trajectoryRuntime, uniqueStrings, usageExactCommands,
     validTaskScopePattern, validateNewWorkPlan, verifierCommandInstructions, verifyProjectCapabilityState, workingTreeEvidenceDigest,
-    repositoryFileManifest, resolveTaskScopePatterns,
+    repositoryFileManifest, repositoryFileManifestDetails, resolveTaskScopePatterns,
     workingTreeSnapshot, workingTreeSnapshotHasUnavailableEvidence, writeContextIndex, writeProfileDocumentWithLock, writeProfileFromAdapter, writeProjectOnboarding,
     writeTask, writeTechStackSelection
   };