autoremediator 0.7.0 → 0.8.0

package/dist/{chunk-MUFP2DQX.js → chunk-5S4Y3WVZ.js}

@@ -1,57 +1,139 @@
 // src/remediation/pipeline.ts
 import { generateText as generateText2 } from "ai";
 
+// src/platform/policy.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var DEFAULT_POLICY = {
+  allowMajorBumps: false,
+  denyPackages: [],
+  allowPackages: [],
+  constraints: {
+    directDependenciesOnly: false,
+    preferVersionBump: false
+  },
+  modelDefaults: {},
+  providerSafetyProfile: "relaxed",
+  requireConsensusForHighRisk: false,
+  dynamicModelRouting: false,
+  dynamicRoutingThresholdChars: 18e3
+};
+function loadPolicy(cwd, explicitPath) {
+  const candidate = explicitPath ?? join(cwd, ".autoremediator.json");
+  if (!existsSync(candidate)) return DEFAULT_POLICY;
+  try {
+    const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+    return {
+      allowMajorBumps: parsed.allowMajorBumps ?? DEFAULT_POLICY.allowMajorBumps,
+      denyPackages: parsed.denyPackages ?? DEFAULT_POLICY.denyPackages,
+      allowPackages: parsed.allowPackages ?? DEFAULT_POLICY.allowPackages,
+      constraints: {
+        directDependenciesOnly: parsed.constraints?.directDependenciesOnly ?? DEFAULT_POLICY.constraints?.directDependenciesOnly ?? false,
+        preferVersionBump: parsed.constraints?.preferVersionBump ?? DEFAULT_POLICY.constraints?.preferVersionBump ?? false
+      },
+      modelDefaults: {
+        remote: parsed.modelDefaults?.remote ?? DEFAULT_POLICY.modelDefaults?.remote,
+        local: parsed.modelDefaults?.local ?? DEFAULT_POLICY.modelDefaults?.local
+      },
+      providerSafetyProfile: parsed.providerSafetyProfile ?? DEFAULT_POLICY.providerSafetyProfile,
+      requireConsensusForHighRisk: parsed.requireConsensusForHighRisk ?? DEFAULT_POLICY.requireConsensusForHighRisk,
+      dynamicModelRouting: parsed.dynamicModelRouting ?? DEFAULT_POLICY.dynamicModelRouting,
+      dynamicRoutingThresholdChars: parsed.dynamicRoutingThresholdChars ?? DEFAULT_POLICY.dynamicRoutingThresholdChars
+    };
+  } catch {
+    return DEFAULT_POLICY;
+  }
+}
+function isPackageAllowed(policy, packageName) {
+  if (policy.denyPackages.includes(packageName)) return false;
+  if (policy.allowPackages.length > 0 && !policy.allowPackages.includes(packageName)) {
+    return false;
+  }
+  return true;
+}
+
 // src/platform/config.ts
 function resolveProvider(options = {}) {
-  const raw = options.llmProvider ?? process.env.AUTOREMEDIATOR_LLM_PROVIDER ?? "openai";
-  if (raw !== "openai" && raw !== "anthropic" && raw !== "local") {
+  const raw = options.llmProvider ?? process.env.AUTOREMEDIATOR_LLM_PROVIDER ?? "remote";
+  if (raw !== "remote" && raw !== "local") {
     throw new Error(
-      `Unsupported LLM provider "${raw}". Set AUTOREMEDIATOR_LLM_PROVIDER to "openai", "anthropic", or "local".`
+      `Unsupported LLM provider "${raw}". Set AUTOREMEDIATOR_LLM_PROVIDER to "remote" or "local".`
     );
   }
   return raw;
 }
-function resolveModelName(provider, options = {}) {
+function resolveModelName(provider, options = {}, routing = {}) {
   if (options.model) return options.model;
   if (process.env.AUTOREMEDIATOR_MODEL) return process.env.AUTOREMEDIATOR_MODEL;
+  const cwd = options.cwd ?? process.cwd();
+  const policy = loadPolicy(cwd, options.policy);
+  const providerEnvModel = provider === "remote" ? process.env.AUTOREMEDIATOR_MODEL_REMOTE : process.env.AUTOREMEDIATOR_MODEL_LOCAL;
+  if (providerEnvModel) return providerEnvModel;
+  const policyPinnedModel = provider === "remote" ? policy.modelDefaults?.remote : policy.modelDefaults?.local;
+  if (policyPinnedModel) return policyPinnedModel;
   const defaults = {
-    openai: "gpt-4o",
-    anthropic: "claude-sonnet-4-5",
+    remote: "remote-default",
     local: "local"
   };
+  const routingEnabled = options.dynamicModelRouting ?? policy.dynamicModelRouting ?? false;
+  const threshold = options.dynamicRoutingThresholdChars ?? policy.dynamicRoutingThresholdChars ?? 18e3;
+  if (provider === "remote" && routingEnabled && typeof routing.inputChars === "number" && routing.inputChars >= threshold) {
+    return process.env.AUTOREMEDIATOR_MODEL_REMOTE_LARGE ?? "remote-large";
+  }
   return defaults[provider];
 }
-async function createModel(options = {}) {
+async function loadRemoteFactory() {
+  const moduleName = process.env.AUTOREMEDIATOR_REMOTE_CLIENT_MODULE;
+  const exportName = process.env.AUTOREMEDIATOR_REMOTE_CLIENT_FACTORY ?? "createRemoteClient";
+  if (!moduleName) {
+    throw new Error(
+      "AUTOREMEDIATOR_REMOTE_CLIENT_MODULE is required for remote provider model loading."
+    );
+  }
+  const loaded = await import(moduleName);
+  const factory = loaded[exportName];
+  if (typeof factory !== "function") {
+    throw new Error(
+      `Remote client factory "${exportName}" was not found in module "${moduleName}".`
+    );
+  }
+  return factory;
+}
+async function createModel(options = {}, routing = {}) {
   const provider = resolveProvider(options);
   if (provider === "local") {
     throw new Error(
       "Local provider does not create a language model. Use the deterministic pipeline path instead."
     );
   }
-  const modelName = resolveModelName(provider, options);
-  if (provider === "openai") {
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-      throw new Error(
-        "OPENAI_API_KEY environment variable is required when using the openai provider."
-      );
-    }
-    const { createOpenAI } = await import("@ai-sdk/openai");
-    const openai = createOpenAI({ apiKey });
-    return openai(modelName);
-  }
-  if (provider === "anthropic") {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) {
-      throw new Error(
-        "ANTHROPIC_API_KEY environment variable is required when using the anthropic provider."
-      );
-    }
-    const { createAnthropic } = await import("@ai-sdk/anthropic");
-    const anthropic = createAnthropic({ apiKey });
-    return anthropic(modelName);
+  const apiKey = process.env.AUTOREMEDIATOR_REMOTE_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "AUTOREMEDIATOR_REMOTE_API_KEY environment variable is required for remote provider."
+    );
   }
-  throw new Error(`Unhandled provider: ${provider}`);
+  const modelName = resolveModelName(provider, options, routing);
+  const createRemoteClient = await loadRemoteFactory();
+  const remoteClient = createRemoteClient({ apiKey });
+  return remoteClient(modelName);
+}
+function getPatchConfidenceThreshold(provider, safetyProfile = "relaxed") {
+  void provider;
+  const relaxed = {
+    remote: 0.7,
+    local: 0.7
+  };
+  const strict = {
+    remote: 0.85,
+    local: 0.85
+  };
+  return safetyProfile === "strict" ? strict[provider] : relaxed[provider];
+}
+function estimateModelCostUsd(params) {
+  const inputTokens = params.promptChars / 4;
+  const outputTokens = params.completionChars / 4;
+  const pricePerThousand = params.provider === "remote" ? { input: 6e-3, output: 0.02 } : { input: 0, output: 0 };
+  return inputTokens / 1e3 * pricePerThousand.input + outputTokens / 1e3 * pricePerThousand.output;
 }
 function getNvdConfig() {
   return {
@@ -76,11 +158,11 @@ function getIntelligenceSourceConfig() {
 }
 
 // src/platform/package-manager.ts
-import { existsSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 function detectPackageManager(cwd) {
-  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync2(join2(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join2(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function getPackageManagerCommands(pm) {
@@ -167,49 +249,11 @@ import { readFileSync as readFileSync2, writeFileSync } from "fs";
 import { execa } from "execa";
 import semver from "semver";
 
-// src/platform/policy.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join2 } from "path";
-var DEFAULT_POLICY = {
-  allowMajorBumps: false,
-  denyPackages: [],
-  allowPackages: [],
-  constraints: {
-    directDependenciesOnly: false,
-    preferVersionBump: false
-  }
-};
-function loadPolicy(cwd, explicitPath) {
-  const candidate = explicitPath ?? join2(cwd, ".autoremediator.json");
-  if (!existsSync2(candidate)) return DEFAULT_POLICY;
-  try {
-    const parsed = JSON.parse(readFileSync(candidate, "utf8"));
-    return {
-      allowMajorBumps: parsed.allowMajorBumps ?? DEFAULT_POLICY.allowMajorBumps,
-      denyPackages: parsed.denyPackages ?? DEFAULT_POLICY.denyPackages,
-      allowPackages: parsed.allowPackages ?? DEFAULT_POLICY.allowPackages,
-      constraints: {
-        directDependenciesOnly: parsed.constraints?.directDependenciesOnly ?? DEFAULT_POLICY.constraints?.directDependenciesOnly ?? false,
-        preferVersionBump: parsed.constraints?.preferVersionBump ?? DEFAULT_POLICY.constraints?.preferVersionBump ?? false
-      }
-    };
-  } catch {
-    return DEFAULT_POLICY;
-  }
-}
-function isPackageAllowed(policy, packageName) {
-  if (policy.denyPackages.includes(packageName)) return false;
-  if (policy.allowPackages.length > 0 && !policy.allowPackages.includes(packageName)) {
-    return false;
-  }
-  return true;
-}
-
 // src/platform/repo-lock.ts
 import { mkdir, rm } from "fs/promises";
 import { join as join3 } from "path";
 async function sleep(ms) {
-  await new Promise((resolve) => setTimeout(resolve, ms));
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function acquireRepoLock(cwd, options = {}) {
   const timeoutMs = options.timeoutMs ?? 15e3;
@@ -661,6 +705,9 @@ var applyPatchFileTool = tool3({
     packageName: z3.string().min(1).describe("The npm package name"),
     vulnerableVersion: z3.string().describe("The vulnerable version string"),
     patchContent: z3.string().min(10).optional().describe("Unified diff patch content from generate-patch"),
+    cveId: z3.string().optional().describe("Optional CVE ID associated with this patch artifact"),
+    confidence: z3.number().min(0).max(1).optional().describe("Optional patch confidence score from generate-patch"),
+    riskLevel: z3.enum(["low", "medium", "high"]).optional().describe("Optional risk level from generate-patch"),
     patches: z3.array(
       z3.object({
         filePath: z3.string().min(1),
@@ -679,16 +726,22 @@ var applyPatchFileTool = tool3({
     packageName,
     vulnerableVersion,
     patchContent,
+    cveId,
+    confidence,
     patches,
     patchesDir,
     cwd,
     packageManager,
+    riskLevel,
     validateWithTests,
     dryRun
   }) => {
     try {
       const pm = packageManager ?? detectPackageManager(cwd);
       const selectedPatch = patchContent ?? patches?.[0]?.unifiedDiff;
+      const patchFiles = extractPatchedFiles(selectedPatch ?? "");
+      const hunkCount = countPatchHunks(selectedPatch ?? "");
+      const validationPhases = [];
       if (!selectedPatch) {
         return {
           success: false,
@@ -701,6 +754,12 @@ var applyPatchFileTool = tool3({
         };
       }
       const patchValidation = validatePatchDiff(selectedPatch);
+      validationPhases.push({
+        phase: "diff-format",
+        passed: patchValidation.valid,
+        error: patchValidation.valid ? void 0 : patchValidation.error,
+        message: patchValidation.valid ? "Patch content is a valid unified diff." : void 0
+      });
       if (!patchValidation.valid) {
         return {
           success: false,
@@ -709,11 +768,32 @@ var applyPatchFileTool = tool3({
           applied: false,
           dryRun,
           message: patchValidation.error ?? "Patch content is not a valid unified diff.",
+          validationPhases,
           error: patchValidation.error ?? "Patch content is not a valid unified diff."
         };
       }
       const patchFileName = buildPatchFileName(packageName, vulnerableVersion);
       const patchFilePath = join7(cwd, patchesDir, patchFileName);
+      const manifestFilePath = `${patchFilePath}.json`;
+      const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const baseArtifact = {
+        schemaVersion: "1.0",
+        cveId,
+        packageName,
+        vulnerableVersion,
+        patchFilePath,
+        manifestFilePath,
+        patchFileName,
+        patchesDir,
+        confidence,
+        riskLevel,
+        generatedAt,
+        files: patchFiles,
+        hunkCount,
+        applied: false,
+        dryRun,
+        validationPhases
+      };
       if (dryRun) {
         return {
           success: true,
@@ -723,7 +803,10 @@ var applyPatchFileTool = tool3({
           dryRun: true,
           message: `[DRY RUN] Would write and configure patch at ${patchFilePath}.`,
           patchFilePath,
-          patchPath: patchFilePath
+          manifestFilePath,
+          patchPath: patchFilePath,
+          patchArtifact: baseArtifact,
+          validationPhases
         };
       }
       return withRepoLock(cwd, async () => {
@@ -731,21 +814,41 @@ var applyPatchFileTool = tool3({
         const patchesDirPath = join7(cwd, patchesDir);
         await mkdir2(patchesDirPath, { recursive: true });
         await writeFile(patchFilePath, selectedPatch, "utf8");
+        validationPhases.push({
+          phase: "patch-write",
+          passed: true,
+          message: `Patch file written to ${patchFilePath}.`
+        });
         let validationResult;
         const patchMode = await resolvePatchMode(pm, cwd);
         const commands = getPackageManagerCommands(pm);
+        const artifact = {
+          ...baseArtifact,
+          patchMode,
+          validationPhases
+        };
+        await writePatchManifest(manifestFilePath, artifact);
+        validationPhases.push({
+          phase: "manifest-write",
+          passed: true,
+          message: `Patch manifest written to ${manifestFilePath}.`
+        });
+        artifact.validationPhases = validationPhases;
+        await writePatchManifest(manifestFilePath, artifact);
         const applyResult = patchMode === "patch-package" ? await configurePatchPackagePostinstall(cwd, pm) : await applyNativePatch({
           cwd,
           packageName,
           vulnerableVersion,
           patchContent: selectedPatch,
-          patchMode
+          patchMode,
+          validationPhases
         });
         if (!applyResult.success) {
           await cleanupPatchArtifacts({
             cwd,
             packageManager: pm,
             patchFilePath,
+            manifestFilePath,
             patchMode,
             packageJsonSnapshot,
             rerunInstall: patchMode === "patch-package"
@@ -758,12 +861,24 @@ var applyPatchFileTool = tool3({
             dryRun: false,
             message: applyResult.error,
             patchFilePath,
+            manifestFilePath,
             patchPath: patchFilePath,
             patchMode,
             postinstallConfigured: patchMode === "patch-package" ? false : void 0,
+            patchArtifact: {
+              ...artifact,
+              applied: false,
+              validationPhases
+            },
+            validationPhases,
             error: applyResult.error
           };
         }
+        validationPhases.push({
+          phase: "apply",
+          passed: true,
+          message: `Patch applied using ${patchMode}.`
+        });
         if (patchMode === "patch-package") {
           try {
             const [installCmd, ...installArgs] = commands.installPreferOffline;
@@ -771,16 +886,27 @@ var applyPatchFileTool = tool3({
               cwd,
               stdio: "pipe"
             });
+            validationPhases.push({
+              phase: "install",
+              passed: true,
+              message: `${commands.installPreferOffline.join(" ")} completed successfully.`
+            });
           } catch (err) {
             await cleanupPatchArtifacts({
               cwd,
               packageManager: pm,
               patchFilePath,
+              manifestFilePath,
               patchMode,
               packageJsonSnapshot,
               rerunInstall: true
             });
             const error = err instanceof Error ? err.message : String(err);
+            validationPhases.push({
+              phase: "install",
+              passed: false,
+              error
+            });
             return {
               success: false,
               packageName,
@@ -789,9 +915,16 @@ var applyPatchFileTool = tool3({
               dryRun: false,
               message: `Failed to apply patch-package workflow for ${packageName}@${vulnerableVersion}: ${error}`,
               patchFilePath,
+              manifestFilePath,
               patchPath: patchFilePath,
               patchMode,
               postinstallConfigured: false,
+              patchArtifact: {
+                ...artifact,
+                applied: false,
+                validationPhases
+              },
+              validationPhases,
               error: `Failed to apply patch-package workflow for ${packageName}@${vulnerableVersion}: ${error}`
             };
           }
@@ -803,11 +936,17 @@ var applyPatchFileTool = tool3({
               cwd,
               packageManager: pm,
               patchFilePath,
+              manifestFilePath,
               patchMode,
               packageJsonSnapshot,
               rerunInstall: patchMode === "patch-package"
             });
             const validationError = "Patch validation failed after apply; patch marked unresolved.";
+            validationPhases.push({
+              phase: "test",
+              passed: false,
+              error: validationResult.error
+            });
             return {
               success: false,
               packageName,
@@ -816,14 +955,33 @@ var applyPatchFileTool = tool3({
               dryRun: false,
               message: validationError,
               patchFilePath,
+              manifestFilePath,
               patchPath: patchFilePath,
               patchMode,
               postinstallConfigured: false,
+              patchArtifact: {
+                ...artifact,
+                applied: false,
+                validationPhases
+              },
               validation: validationResult,
+              validationPhases,
               error: validationError
             };
           }
+          validationPhases.push({
+            phase: "test",
+            passed: true,
+            message: "Patch validation tests passed."
+          });
         }
+        const finalArtifact = {
+          ...artifact,
+          applied: true,
+          dryRun: false,
+          validationPhases
+        };
+        await writePatchManifest(manifestFilePath, finalArtifact);
         return {
           success: true,
           packageName,
@@ -832,10 +990,13 @@ var applyPatchFileTool = tool3({
           dryRun: false,
           message: `Patch applied successfully for ${packageName}@${vulnerableVersion}.`,
           patchFilePath,
+          manifestFilePath,
           patchPath: patchFilePath,
           patchMode,
           postinstallConfigured: patchMode === "patch-package",
-          validation: validationResult
+          patchArtifact: finalArtifact,
+          validation: validationResult,
+          validationPhases
         };
       });
     } catch (err) {
@@ -926,8 +1087,11 @@ async function capturePackageJsonSnapshot(cwd) {
   }
 }
 async function cleanupPatchArtifacts(params) {
-  const { cwd, packageManager, patchFilePath, patchMode, packageJsonSnapshot, rerunInstall } = params;
+  const { cwd, packageManager, patchFilePath, manifestFilePath, patchMode, packageJsonSnapshot, rerunInstall } = params;
   await rm2(patchFilePath, { force: true }).catch(() => void 0);
+  if (manifestFilePath) {
+    await rm2(manifestFilePath, { force: true }).catch(() => void 0);
+  }
   if (patchMode === "patch-package" && packageJsonSnapshot) {
     await writeFile(packageJsonSnapshot.path, packageJsonSnapshot.content, "utf8").catch(() => void 0);
   }
@@ -943,7 +1107,7 @@ async function cleanupPatchArtifacts(params) {
   }
 }
 async function applyNativePatch(params) {
-  const { cwd, packageName, vulnerableVersion, patchContent, patchMode } = params;
+  const { cwd, packageName, vulnerableVersion, patchContent, patchMode, validationPhases } = params;
   const packageSpec = `${packageName}@${vulnerableVersion}`;
   const createCommand = patchMode === "native-pnpm" ? "pnpm" : "yarn";
   const createArgs = ["patch", packageSpec];
@@ -956,12 +1120,22 @@ async function applyNativePatch(params) {
     patchDir = extractPatchDirectory(`${createResult.stdout}
 ${createResult.stderr}`);
   } catch (err) {
+    validationPhases.push({
+      phase: "apply",
+      passed: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
     return {
       success: false,
       error: `Failed to create native patch workspace for ${packageSpec}: ${err instanceof Error ? err.message : String(err)}`
     };
   }
   if (!patchDir) {
+    validationPhases.push({
+      phase: "apply",
+      passed: false,
+      error: `Could not determine native patch directory for ${packageSpec}.`
+    });
     return {
       success: false,
       error: `Could not determine native patch directory for ${packageSpec}.`
@@ -982,6 +1156,11 @@ ${createResult.stderr}`);
       stdio: "pipe"
     });
   } catch (err) {
+    validationPhases.push({
+      phase: "apply",
+      passed: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
     return {
       success: false,
       error: `Failed to apply native patch for ${packageSpec}: ${err instanceof Error ? err.message : String(err)}`
@@ -991,6 +1170,19 @@ ${createResult.stderr}`);
   }
   return { success: true };
 }
+async function writePatchManifest(manifestFilePath, artifact) {
+  await writeFile(manifestFilePath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
+}
+function extractPatchedFiles(patchContent) {
+  return Array.from(
+    new Set(
+      patchContent.split(/\r?\n/).filter((line) => line.startsWith("+++ b/")).map((line) => line.slice("+++ b/".length))
+    )
+  );
+}
+function countPatchHunks(patchContent) {
+  return patchContent.split(/\r?\n/).filter((line) => line.startsWith("@@ ")).length;
+}
 function extractPatchDirectory(output) {
   const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   for (const line of lines) {
@@ -1640,7 +1832,15 @@ var generatePatchTool = tool6({
       "Map of file paths to source code contents from fetch-package-source"
     ),
     vulnerabilityCategory: z6.enum(["redos", "code-injection", "path-traversal", "unknown"]).optional().default("unknown").describe("Category of the vulnerability for better context"),
-    dryRun: z6.boolean().optional().default(false).describe("If true, return analysis without generating patches")
+    dryRun: z6.boolean().optional().default(false).describe("If true, return analysis without generating patches"),
+    llmProvider: z6.enum(["remote", "local"]).optional().describe("Optional provider override for patch generation"),
+    model: z6.string().optional().describe("Optional model override for patch generation"),
+    policy: z6.string().optional().describe("Optional policy file path for model default resolution"),
+    cwd: z6.string().optional().describe("Optional working directory for policy/model resolution"),
+    providerSafetyProfile: z6.enum(["strict", "relaxed"]).optional().describe("Confidence threshold profile for patch acceptance"),
+    dynamicModelRouting: z6.boolean().optional().describe("Enable dynamic model routing by input size"),
+    dynamicRoutingThresholdChars: z6.number().int().positive().optional().describe("Threshold for dynamic model routing"),
+    modelPersonality: z6.enum(["analytical", "pragmatic", "balanced"]).optional().describe("Prompt personality for patch-generation guidance")
   }),
   execute: async ({
     packageName,
@@ -1649,27 +1849,49 @@ var generatePatchTool = tool6({
     cveSummary,
     sourceFiles,
     vulnerabilityCategory,
-    dryRun
+    dryRun,
+    llmProvider,
+    model,
+    policy,
+    cwd,
+    providerSafetyProfile,
+    dynamicModelRouting,
+    dynamicRoutingThresholdChars,
+    modelPersonality
   }) => {
     try {
       const resolvedSourceFiles = sourceFiles;
+      const effectiveOptions = {
+        llmProvider,
+        model,
+        policy,
+        cwd,
+        providerSafetyProfile,
+        dynamicModelRouting,
+        dynamicRoutingThresholdChars,
+        modelPersonality
+      };
+      const provider = resolveProvider(effectiveOptions);
       if (Object.keys(resolvedSourceFiles).length === 0) {
         return {
           success: false,
+          llmProvider: provider,
           llmModel: "unknown",
           confidence: 0,
           riskLevel: "high",
           error: "No source files were provided. Call fetch-package-source first and pass sourceFiles."
         };
       }
-      const model = await createModel();
-      const modelName = model.modelId || "unknown-model";
+      const inputChars = JSON.stringify(resolvedSourceFiles).length + cveSummary.length;
+      const modelInstance = await createModel(effectiveOptions, { inputChars });
+      const modelName = modelInstance.modelId || "unknown-model";
       const sourceContext = Object.entries(resolvedSourceFiles).map(([filePath, content]) => `
 ### File: ${filePath}
 \`\`\`typescript
 ${content}
 \`\`\``).join("\n");
       const vulnerabilityContext = VULNERABILITY_DESCRIPTIONS[vulnerabilityCategory] || VULNERABILITY_DESCRIPTIONS.unknown;
+      const personalityDirective = modelPersonality === "analytical" ? "Provide concise analysis with explicit risk tradeoffs." : modelPersonality === "pragmatic" ? "Prioritize minimal, safe changes with low operational risk." : "Balance analytical explanation with practical remediation.";
       const prompt = `You are a security expert tasked with analyzing a CVE vulnerability and generating a secure patch.
 
 ## CVE Information
@@ -1683,6 +1905,9 @@ ${cveSummary}
 ## Vulnerability Type Context
 ${vulnerabilityContext}
 
+## Model Behavior
+${personalityDirective}
+
 ## Vulnerable Source Code
 ${sourceContext}
 
@@ -1710,12 +1935,14 @@ Important:
 - riskLevel: "low", "medium", or "high" - assess the risk of the proposed fix breaking functionality
 - fixedCode: must contain the COMPLETE file contents (not just diffs), with the vulnerability addressed
 - Only include files that need modification`;
+      const started = Date.now();
       const { text } = await generateText({
-        model,
+        model: modelInstance,
         prompt,
         temperature: 0.3
         // Lower temperature for more consistent code generation
       });
+      const latencyMs = Date.now() - started;
       let analysis;
       try {
         const jsonMatch = text.match(/\{[\s\S]*\}/);
@@ -1726,25 +1953,42 @@ Important:
       } catch (err) {
         return {
           success: false,
+          llmProvider: provider,
           llmModel: modelName,
           confidence: 0,
           riskLevel: "high",
+          latencyMs,
           error: `Failed to parse LLM response: ${err instanceof Error ? err.message : "unknown error"}`
         };
       }
       if (!analysis.analysis || !analysis.fixedCode || typeof analysis.confidence !== "number" || !["low", "medium", "high"].includes(analysis.riskLevel)) {
         return {
           success: false,
+          llmProvider: provider,
           llmModel: modelName,
           confidence: 0,
           riskLevel: "high",
+          latencyMs,
           error: "LLM response missing required fields (analysis, fixedCode, confidence, riskLevel)"
         };
       }
+      const confidenceThreshold = getPatchConfidenceThreshold(
+        provider,
+        providerSafetyProfile ?? "relaxed"
+      );
+      const estimatedCostUsd = estimateModelCostUsd({
+        provider,
+        promptChars: prompt.length,
+        completionChars: text.length
+      });
       if (dryRun) {
         return {
           success: true,
+          llmProvider: provider,
           llmModel: modelName,
+          latencyMs,
+          estimatedCostUsd,
+          confidenceThreshold,
           confidence: analysis.confidence,
           riskLevel: analysis.riskLevel
         };
@@ -1772,7 +2016,11 @@ Important:
       if (patches.length === 0) {
         return {
           success: false,
+          llmProvider: provider,
           llmModel: modelName,
+          latencyMs,
+          estimatedCostUsd,
+          confidenceThreshold,
           confidence: analysis.confidence,
           riskLevel: analysis.riskLevel,
           error: "No valid patches could be generated from LLM response"
@@ -1782,7 +2030,11 @@ Important:
         success: true,
         patches,
         patchContent: patches[0]?.unifiedDiff,
+        llmProvider: provider,
         llmModel: modelName,
+        latencyMs,
+        estimatedCostUsd,
+        confidenceThreshold,
         confidence: analysis.confidence,
         riskLevel: analysis.riskLevel
       };
@@ -1790,6 +2042,7 @@ Important:
       const message = err instanceof Error ? err.message : String(err);
       return {
         success: false,
+        llmProvider: "local",
         llmModel: "unknown",
         confidence: 0,
         riskLevel: "high",
@@ -1827,12 +2080,17 @@ function generateUnifiedDiff(original, fixed, filePath) {
 }
 
 // src/remediation/local/fallback.ts
+function resolvePatchProvider(provider) {
+  void provider;
+  return "remote";
+}
 function shouldAttemptPatchFallback(result, preferVersionBump) {
   if (preferVersionBump) return false;
   if (result.applied || result.dryRun) return false;
   return result.unresolvedReason === "no-safe-version" || result.unresolvedReason === "install-failed" || result.unresolvedReason === "override-apply-failed" || result.unresolvedReason === "validation-failed" || result.unresolvedReason === "major-bump-required" || result.unresolvedReason === "indirect-dependency";
 }
 async function tryLocalPatchFallback(params) {
+  const usage = [];
   let steps = 0;
   const sourceResult = await fetchPackageSourceTool.execute({
     packageName: params.packageName,
@@ -1842,17 +2100,20 @@ async function tryLocalPatchFallback(params) {
   if (!sourceResult?.success || !sourceResult.sourceFiles) {
     return {
       steps,
+      usage,
       result: {
         packageName: params.packageName,
         strategy: "none",
         fromVersion: params.vulnerableVersion,
         applied: false,
         dryRun: params.dryRun,
+        dependencyScope: params.dependencyScope,
         unresolvedReason: "source-fetch-failed",
         message: sourceResult?.error ?? `Failed to fetch source for ${params.packageName}@${params.vulnerableVersion}.`
       }
     };
   }
+  const primaryProvider = resolvePatchProvider(params.llmProvider);
   const patchResult = await generatePatchTool.execute({
     packageName: params.packageName,
     vulnerableVersion: params.vulnerableVersion,
@@ -1860,7 +2121,15 @@ async function tryLocalPatchFallback(params) {
     cveSummary: params.cveSummary,
     sourceFiles: sourceResult.sourceFiles,
     vulnerabilityCategory: "unknown",
-    dryRun: params.dryRun
+    dryRun: params.dryRun,
+    llmProvider: primaryProvider,
+    model: params.model,
+    policy: params.policy,
+    cwd: params.cwd,
+    modelPersonality: params.modelPersonality,
+    providerSafetyProfile: params.providerSafetyProfile,
+    dynamicModelRouting: params.dynamicModelRouting,
+    dynamicRoutingThresholdChars: params.dynamicRoutingThresholdChars
   });
   steps += 1;
   if (!patchResult?.success) {
@@ -1868,58 +2137,121 @@ async function tryLocalPatchFallback(params) {
     const unresolvedReason = error.includes("API_KEY") || error.includes("does not create a language model") ? "requires-llm-fallback" : "patch-generation-failed";
     return {
       steps,
+      usage,
       result: {
         packageName: params.packageName,
         strategy: "none",
         fromVersion: params.vulnerableVersion,
         applied: false,
         dryRun: params.dryRun,
+        dependencyScope: params.dependencyScope,
         unresolvedReason,
         message: error
       }
     };
   }
-  if (typeof patchResult.confidence === "number" && patchResult.confidence < 0.7) {
+  const effectiveProvider = patchResult.llmProvider ?? primaryProvider;
+  const confidenceThreshold = patchResult.confidenceThreshold ?? getPatchConfidenceThreshold(effectiveProvider, params.providerSafetyProfile ?? "relaxed");
+  if (typeof patchResult.confidence === "number" && patchResult.confidence < confidenceThreshold) {
     return {
       steps,
+      usage,
       result: {
         packageName: params.packageName,
         strategy: "none",
         fromVersion: params.vulnerableVersion,
         applied: false,
         dryRun: params.dryRun,
+        dependencyScope: params.dependencyScope,
+        confidence: patchResult.confidence,
+        riskLevel: patchResult.riskLevel,
         unresolvedReason: "patch-confidence-too-low",
-        message: `Patch confidence ${patchResult.confidence.toFixed(2)} is below threshold 0.70.`
+        message: `Patch confidence ${patchResult.confidence.toFixed(2)} is below threshold ${confidenceThreshold.toFixed(2)}.`
       }
     };
   }
+  if (params.requireConsensusForHighRisk && patchResult.riskLevel === "high" && !params.dryRun) {
+    const consensus = await generatePatchTool.execute({
+      packageName: params.packageName,
+      vulnerableVersion: params.vulnerableVersion,
+      cveId: params.cveId,
+      cveSummary: params.cveSummary,
+      sourceFiles: sourceResult.sourceFiles,
+      vulnerabilityCategory: "unknown",
+      dryRun: false,
+      llmProvider: "remote",
+      policy: params.policy,
+      cwd: params.cwd,
+      modelPersonality: params.modelPersonality,
+      providerSafetyProfile: params.providerSafetyProfile,
+      dynamicModelRouting: params.dynamicModelRouting,
+      dynamicRoutingThresholdChars: params.dynamicRoutingThresholdChars
+    });
+    steps += 1;
+    const primaryDiff = patchResult.patches?.[0]?.unifiedDiff;
+    const secondaryDiff = consensus.patches?.[0]?.unifiedDiff;
+    if (!consensus.success || !primaryDiff || !secondaryDiff || primaryDiff !== secondaryDiff) {
+      return {
+        steps,
+        usage,
+        result: {
+          packageName: params.packageName,
+          strategy: "none",
+          fromVersion: params.vulnerableVersion,
+          applied: false,
+          dryRun: params.dryRun,
+          dependencyScope: params.dependencyScope,
+          unresolvedReason: "consensus-failed",
+          message: consensus.error ?? "High-risk patch did not pass consensus verification."
+        }
+      };
+    }
+  }
   const applyResult = await applyPatchFileTool.execute({
     packageName: params.packageName,
     vulnerableVersion: params.vulnerableVersion,
+    cveId: params.cveId,
+    confidence: patchResult.confidence,
     patchContent: patchResult.patchContent,
     patches: patchResult.patches,
     patchesDir: params.patchesDir,
     cwd: params.cwd,
     packageManager: params.packageManager,
+    riskLevel: patchResult.riskLevel,
     validateWithTests: params.runTests,
     dryRun: params.dryRun
   });
   steps += 1;
+  if (patchResult.llmProvider && patchResult.llmModel) {
+    usage.push({
+      purpose: "patch-generation",
+      provider: patchResult.llmProvider,
+      model: patchResult.llmModel,
+      latencyMs: patchResult.latencyMs,
+      estimatedCostUsd: patchResult.estimatedCostUsd
+    });
+  }
   return {
     steps,
+    usage,
     result: {
       packageName: params.packageName,
       strategy: "patch-file",
       fromVersion: params.vulnerableVersion,
       patchFilePath: applyResult.patchFilePath ?? applyResult.patchPath,
+      patchArtifact: applyResult.patchArtifact,
       applied: Boolean(applyResult.applied),
       dryRun: Boolean(applyResult.dryRun),
+      dependencyScope: params.dependencyScope,
+      confidence: patchResult.confidence,
+      riskLevel: patchResult.riskLevel,
       unresolvedReason: !Boolean(applyResult.applied) && !Boolean(applyResult.dryRun) ? applyResult.validation?.passed === false ? "patch-validation-failed" : "patch-apply-failed" : void 0,
       message: applyResult.message ?? applyResult.error ?? "Patch-file strategy finished.",
       validation: typeof applyResult.validation?.passed === "boolean" ? {
         passed: applyResult.validation.passed,
         error: applyResult.validation.error
-      } : void 0
+      } : void 0,
+      validationPhases: applyResult.validationPhases
     }
   };
 }
@@ -1934,7 +2266,14 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
   const policy = options.policy ?? "";
   const patchesDir = options.patchesDir || "./patches";
   const constraints = options.constraints ?? {};
+  const loadedPolicy = loadPolicy(cwd, options.policy);
+  const llmProvider = resolveProvider(options);
+  const providerSafetyProfile = options.providerSafetyProfile ?? loadedPolicy.providerSafetyProfile ?? "relaxed";
+  const requireConsensusForHighRisk = options.requireConsensusForHighRisk ?? loadedPolicy.requireConsensusForHighRisk ?? false;
+  const dynamicModelRouting = options.dynamicModelRouting ?? loadedPolicy.dynamicModelRouting ?? false;
+  const dynamicRoutingThresholdChars = options.dynamicRoutingThresholdChars ?? loadedPolicy.dynamicRoutingThresholdChars;
   const collectedResults = [];
+  const llmUsage = [];
   const vulnerablePackages = [];
   let cveDetails = null;
   let agentSteps = 0;
@@ -2043,15 +2382,30 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
         vulnerableVersion: vulnerable.installed.version,
         cveId: normalizedId,
         cveSummary: cveDetails?.summary ?? normalizedId,
+        dependencyScope: vulnerable.installed.type === "direct" ? "direct" : "transitive",
         dryRun,
         runTests,
-        patchesDir
+        patchesDir,
+        llmProvider,
+        model: options.model,
+        policy: options.policy,
+        modelPersonality: options.modelPersonality,
+        providerSafetyProfile,
+        requireConsensusForHighRisk,
+        dynamicModelRouting,
+        dynamicRoutingThresholdChars
       });
       agentSteps += fallback.steps;
       collectedResults.push(fallback.result);
+      if (fallback.usage) {
+        llmUsage.push(...fallback.usage);
+      }
       continue;
     }
-    collectedResults.push(primary.result);
+    collectedResults.push({
+      ...primary.result,
+      dependencyScope: vulnerable.installed.type === "direct" ? "direct" : "transitive"
+    });
   }
   const appliedCount = collectedResults.filter((result) => result.applied).length;
   const unresolvedCount = collectedResults.filter((result) => !result.applied && !result.dryRun).length;
@@ -2063,6 +2417,7 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
     results: collectedResults,
     agentSteps,
     summary: `Local mode completed: vulnerable=${vulnerablePackages.length}, applied=${appliedCount}, dryRun=${dryRunCount}, unresolved=${unresolvedCount}`,
+    llmUsage: llmUsage.length > 0 ? llmUsage : void 0,
     correlation: {
       requestId: options.requestId,
       sessionId: options.sessionId,
@@ -2071,6 +2426,50 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
   };
 }
 
+// src/remediation/orchestration-prompt.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
+import { join as join10 } from "path";
+function buildProviderAddendum(provider, personality = "balanced") {
+  const personalityDirective = personality === "analytical" ? "Use concise, explicit rationale for tool decisions and unresolved outcomes." : personality === "pragmatic" ? "Prefer the smallest safe remediation path while preserving policy and validation gates." : "Balance concise execution with brief rationale for risky or unresolved outcomes.";
+  const providerDirective = provider === "remote" ? "Use strict structured output and deterministic reporting fields." : "Use deterministic-first behavior and only rely on remote model fallback when required by patch generation.";
+  return `
+Provider profile:
+- Provider: ${provider}
+- ${providerDirective}
+- ${personalityDirective}`;
+}
+function loadOrchestrationPrompt(ctx) {
+  const promptPath = join10(process.cwd(), ".github", "instructions", "orchestration.instructions.md");
+  if (!existsSync5(promptPath)) {
+    return `You are autoremediator, an agentic security remediation system for Node.js package dependencies.
+Working directory: ${ctx.cwd}
+  Package manager: ${ctx.packageManager}
+Dry run: ${ctx.dryRun}
+Run tests: ${ctx.runTests}
+Policy: ${ctx.policy || "undefined"}
+Patches dir: ${ctx.patchesDir}
+Direct dependencies only: ${String(ctx.constraints.directDependenciesOnly ?? false)}
+Prefer version bump: ${String(ctx.constraints.preferVersionBump ?? false)}
+
+Required sequence:
+1. lookup-cve
+2. check-inventory
+3. check-version-match
+4. find-fixed-version
+5. apply-version-bump
+6. apply-package-override
+
+Fallback sequence (when neither version bump nor override can be applied):
+1. fetch-package-source
+2. generate-patch
+3. apply-patch-file
+
+Always respect dryRun and policy constraints.`;
+  }
+  const template = readFileSync6(promptPath, "utf8");
+  return template.replaceAll("{{cveId}}", ctx.cveId).replaceAll("{{cwd}}", ctx.cwd).replaceAll("{{packageManager}}", ctx.packageManager).replaceAll("{{dryRun}}", String(ctx.dryRun)).replaceAll("{{runTests}}", String(ctx.runTests)).replaceAll("{{policy}}", ctx.policy || "undefined").replaceAll("{{patchesDir}}", ctx.patchesDir).replaceAll("{{directDependenciesOnly}}", String(ctx.constraints.directDependenciesOnly ?? false)).replaceAll("{{preferVersionBump}}", String(ctx.constraints.preferVersionBump ?? false)) + buildProviderAddendum(ctx.llmProvider, ctx.modelPersonality);
+}
+
 // src/remediation/tools/lookup-cve.ts
 import { tool as tool7 } from "ai";
 import { z as z7 } from "zod";
@@ -2544,47 +2943,23 @@ function buildRuntimeTools(ctx) {
   return tools;
 }
 
-// src/remediation/orchestration-prompt.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { join as join10 } from "path";
-function loadOrchestrationPrompt(ctx) {
-  const promptPath = join10(process.cwd(), ".github", "instructions", "orchestration.instructions.md");
-  if (!existsSync5(promptPath)) {
-    return `You are autoremediator, an agentic security remediation system for Node.js package dependencies.
-Working directory: ${ctx.cwd}
-  Package manager: ${ctx.packageManager}
-Dry run: ${ctx.dryRun}
-Run tests: ${ctx.runTests}
-Policy: ${ctx.policy || "undefined"}
-Patches dir: ${ctx.patchesDir}
-Direct dependencies only: ${String(ctx.constraints.directDependenciesOnly ?? false)}
-Prefer version bump: ${String(ctx.constraints.preferVersionBump ?? false)}
-
-Required sequence:
-1. lookup-cve
-2. check-inventory
-3. check-version-match
-4. find-fixed-version
-5. apply-version-bump
-6. apply-package-override
-
-Fallback sequence (when neither version bump nor override can be applied):
-1. fetch-package-source
-2. generate-patch
-3. apply-patch-file
-
-Always respect dryRun and policy constraints.`;
-  }
-  const template = readFileSync6(promptPath, "utf8");
-  return template.replaceAll("{{cveId}}", ctx.cveId).replaceAll("{{cwd}}", ctx.cwd).replaceAll("{{packageManager}}", ctx.packageManager).replaceAll("{{dryRun}}", String(ctx.dryRun)).replaceAll("{{runTests}}", String(ctx.runTests)).replaceAll("{{policy}}", ctx.policy || "undefined").replaceAll("{{patchesDir}}", ctx.patchesDir).replaceAll("{{directDependenciesOnly}}", String(ctx.constraints.directDependenciesOnly ?? false)).replaceAll("{{preferVersionBump}}", String(ctx.constraints.preferVersionBump ?? false));
-}
-
 // src/remediation/pipeline.ts
 async function runRemediationPipeline(cveId, options = {}) {
   const provider = resolveProvider(options);
   if (provider === "local") {
     return runLocalRemediationPipeline(cveId, options);
   }
+  const emitProgress = (stage, detail, extra) => {
+    if (!options.onProgress) return;
+    options.onProgress({
+      stage,
+      detail,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      provider: extra?.provider,
+      model: extra?.model
+    });
+  };
+  emitProgress("pipeline-start", `Starting remediation for ${cveId}.`, { provider });
   const cwd = options.cwd ?? process.cwd();
   const packageManager = options.packageManager ?? detectPackageManager(cwd);
   const preview = options.preview ?? false;
@@ -2593,10 +2968,15 @@ async function runRemediationPipeline(cveId, options = {}) {
   const policy = options.policy ?? "";
   const patchesDir = options.patchesDir || "./patches";
   const constraints = options.constraints ?? {};
-  const model = await createModel(options);
+  const prompt = `Patch vulnerable dependencies affected by ${cveId} in the project at: ${cwd}. Package manager: ${packageManager}.`;
+  const model = await createModel(options, { inputChars: prompt.length });
+  const modelName = model.modelId ?? "unknown-model";
+  emitProgress("model-selected", `Selected model ${modelName}.`, { provider, model: modelName });
   const systemPrompt = loadOrchestrationPrompt({
     cveId,
     cwd,
+    llmProvider: provider,
+    modelPersonality: options.modelPersonality,
     dryRun,
     runTests,
     policy,
@@ -2604,11 +2984,15 @@ async function runRemediationPipeline(cveId, options = {}) {
     packageManager,
     constraints
   });
-  const prompt = `Patch vulnerable dependencies affected by ${cveId} in the project at: ${cwd}. Package manager: ${packageManager}.`;
   const collectedResults = [];
   const vulnerablePackages = [];
   let cveDetails = null;
   let agentSteps = 0;
+  function getDependencyScope(packageName) {
+    const match = vulnerablePackages.find((pkg) => pkg.installed.name === packageName);
+    if (!match) return void 0;
+    return match.installed.type === "direct" ? "direct" : "transitive";
+  }
   const applyVersionBumpToolForRun = preview ? {
     ...applyVersionBumpTool,
     execute: async (input) => applyVersionBumpTool.execute({ ...input, dryRun: true })
@@ -2627,6 +3011,7 @@ async function runRemediationPipeline(cveId, options = {}) {
     applyPatchFileToolForRun,
     constraints
   });
+  const started = Date.now();
   const result = await generateText2({
     model,
     system: systemPrompt,
@@ -2645,10 +3030,18 @@ async function runRemediationPipeline(cveId, options = {}) {
           vulnerablePackages.push(...toolResult.vulnerablePackages);
         }
         if (tr.toolName === "apply-version-bump") {
-          collectedResults.push(toolResult);
+          const typed = toolResult;
+          collectedResults.push({
+            ...typed,
+            dependencyScope: typed.packageName ? getDependencyScope(typed.packageName) : typed.dependencyScope
+          });
         }
         if (tr.toolName === "apply-package-override") {
-          collectedResults.push(toolResult);
+          const typed = toolResult;
+          collectedResults.push({
+            ...typed,
+            dependencyScope: typed.packageName ? getDependencyScope(typed.packageName) : typed.dependencyScope
+          });
         }
         if (tr.toolName === "apply-patch-file" && toolResult) {
           const validation = toolResult.validation;
@@ -2658,19 +3051,47 @@ async function runRemediationPipeline(cveId, options = {}) {
             strategy: "patch-file",
             fromVersion: typeof toolResult.vulnerableVersion === "string" ? toolResult.vulnerableVersion : "unknown",
             patchFilePath: typeof toolResult.patchFilePath === "string" ? toolResult.patchFilePath : typeof toolResult.patchPath === "string" ? toolResult.patchPath : void 0,
+            patchArtifact: typeof toolResult.patchArtifact === "object" && toolResult.patchArtifact !== null ? toolResult.patchArtifact : void 0,
             applied: Boolean(toolResult.applied),
             dryRun: Boolean(toolResult.dryRun),
+            dependencyScope: typeof toolResult.packageName === "string" ? getDependencyScope(toolResult.packageName) : void 0,
+            confidence: typeof toolResult.patchArtifact === "object" && toolResult.patchArtifact !== null && typeof toolResult.patchArtifact.confidence === "number" ? toolResult.patchArtifact.confidence : void 0,
+            riskLevel: typeof toolResult.patchArtifact === "object" && toolResult.patchArtifact !== null && typeof toolResult.patchArtifact.riskLevel === "string" ? toolResult.patchArtifact.riskLevel : void 0,
             unresolvedReason: !Boolean(toolResult.applied) && !Boolean(toolResult.dryRun) ? validation && validation.passed === false ? "patch-validation-failed" : "patch-apply-failed" : void 0,
             message,
             validation: validation && typeof validation.passed === "boolean" ? {
               passed: validation.passed,
               error: typeof validation.error === "string" ? validation.error : void 0
-            } : void 0
+            } : void 0,
+            validationPhases: Array.isArray(toolResult.validationPhases) ? toolResult.validationPhases : void 0
           });
         }
       }
+      emitProgress("agent-step", `Completed agent step ${agentSteps} with ${toolResults.length} tool result(s).`, {
+        provider,
+        model: modelName
+      });
     }
   });
+  const llmUsage = [
+    {
+      purpose: "orchestration",
+      provider,
+      model: modelName,
+      latencyMs: Date.now() - started,
+      promptChars: prompt.length + systemPrompt.length,
+      completionChars: result.text.length,
+      estimatedCostUsd: estimateModelCostUsd({
+        provider,
+        promptChars: prompt.length + systemPrompt.length,
+        completionChars: result.text.length
+      })
+    }
+  ];
+  emitProgress("pipeline-finish", `Completed remediation with ${collectedResults.length} result(s).`, {
+    provider,
+    model: modelName
+  });
   return {
     cveId,
     cveDetails,
@@ -2678,6 +3099,7 @@ async function runRemediationPipeline(cveId, options = {}) {
     results: collectedResults,
     agentSteps,
     summary: result.text,
+    llmUsage,
     correlation: {
       requestId: options.requestId,
       sessionId: options.sessionId,
@@ -2688,7 +3110,7 @@ async function runRemediationPipeline(cveId, options = {}) {
 
 // src/api/options-schema.ts
 var PACKAGE_MANAGER_VALUES = ["npm", "pnpm", "yarn"];
-var LLM_PROVIDER_VALUES = ["openai", "anthropic", "local"];
+var LLM_PROVIDER_VALUES = ["remote", "local"];
 var PROVENANCE_SOURCE_VALUES = ["cli", "sdk", "mcp", "openapi", "unknown"];
 var OPTION_DESCRIPTIONS = {
   cveId: "CVE ID, e.g. CVE-2021-23337",
@@ -2698,7 +3120,13 @@ var OPTION_DESCRIPTIONS = {
   dryRun: "If true, plan changes but write nothing",
   preview: "If true, enforce non-mutating preview mode",
   runTests: "Run package-manager test command after applying fix",
-  llmProvider: "LLM provider override",
+  llmProvider: "LLM provider override (remote|local)",
+  model: "LLM model override",
+  modelPersonality: "Prompt behavior profile: analytical|pragmatic|balanced",
+  providerSafetyProfile: "Safety posture profile for confidence gates: strict|relaxed",
+  requireConsensusForHighRisk: "Require second-provider agreement for high-risk generated patches",
+  dynamicModelRouting: "Enable dynamic model selection by input size",
+  dynamicRoutingThresholdChars: "Input size threshold used by dynamic model routing",
   patchesDir: "Directory to write .patch files (default: ./patches)",
   policy: "Optional path to .autoremediator policy file",
   requestId: "Request correlation ID",
@@ -2730,6 +3158,12 @@ function createRemediateOptionSchemaProperties(options) {
     ...includePreview ? { preview: { type: "boolean", description: OPTION_DESCRIPTIONS.preview } } : {},
     runTests: { type: "boolean", description: OPTION_DESCRIPTIONS.runTests },
     llmProvider: { type: "string", enum: [...LLM_PROVIDER_VALUES], description: OPTION_DESCRIPTIONS.llmProvider },
+    model: { type: "string", description: OPTION_DESCRIPTIONS.model },
+    modelPersonality: { type: "string", enum: ["analytical", "pragmatic", "balanced"], description: OPTION_DESCRIPTIONS.modelPersonality },
+    providerSafetyProfile: { type: "string", enum: ["strict", "relaxed"], description: OPTION_DESCRIPTIONS.providerSafetyProfile },
+    requireConsensusForHighRisk: { type: "boolean", description: OPTION_DESCRIPTIONS.requireConsensusForHighRisk },
+    dynamicModelRouting: { type: "boolean", description: OPTION_DESCRIPTIONS.dynamicModelRouting },
+    dynamicRoutingThresholdChars: { type: "number", description: OPTION_DESCRIPTIONS.dynamicRoutingThresholdChars },
     patchesDir: { type: "string", description: OPTION_DESCRIPTIONS.patchesDir },
     policy: { type: "string", description: OPTION_DESCRIPTIONS.policy },
     ...includeEvidence ? { evidence: { type: "boolean", description: OPTION_DESCRIPTIONS.evidence } } : {},
@@ -2781,7 +3215,10 @@ function createScanReportSchemaProperties() {
     correlation: { type: "object" },
     provenance: { type: "object" },
     constraints: { type: "object" },
-    idempotencyKey: { type: "string" }
+    idempotencyKey: { type: "string" },
+    llmUsageCount: { type: "number" },
+    estimatedCostUsd: { type: "number" },
+    totalLlmLatencyMs: { type: "number" }
   };
 }
 
@@ -2851,7 +3288,10 @@ function toCiSummary(report) {
     correlation: report.correlation,
     provenance: report.provenance,
     constraints: report.constraints,
-    idempotencyKey: report.idempotencyKey
+    idempotencyKey: report.idempotencyKey,
+    llmUsageCount: report.llmUsageCount,
+    estimatedCostUsd: report.estimatedCostUsd,
+    totalLlmLatencyMs: report.totalLlmLatencyMs
   };
 }
 function ciExitCode(summary) {
@@ -2921,9 +3361,219 @@ function toSarifOutput(report) {
   };
 }
 
+// src/api/patches.ts
+import { existsSync as existsSync6 } from "fs";
+import { readdir as readdir2, readFile as readFile3, stat } from "fs/promises";
+import { isAbsolute, join as join11, resolve } from "path";
+var DEFAULT_PATCHES_DIR = "./patches";
+async function listPatchArtifacts(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const patchesDirPath = resolvePatchesDir(cwd, options.patchesDir);
+  if (!existsSync6(patchesDirPath)) {
+    return [];
+  }
+  const entries = await readdir2(patchesDirPath, { withFileTypes: true });
+  const patchFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".patch")).map((entry) => join11(patchesDirPath, entry.name)).sort((left, right) => left.localeCompare(right));
+  const summaries = await Promise.all(
+    patchFiles.map(async (patchFilePath) => {
+      const inspection = await inspectPatchArtifact(patchFilePath, options);
+      return toSummary(inspection);
+    })
+  );
+  return summaries;
+}
+async function inspectPatchArtifact(patchFilePath, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const resolvedPatchPath = resolveArtifactPath(cwd, patchFilePath);
+  const patchFileName = resolvedPatchPath.split("/").pop() ?? resolvedPatchPath;
+  const manifestFilePath = `${resolvedPatchPath}.json`;
+  if (!existsSync6(resolvedPatchPath)) {
+    return {
+      patchFilePath: resolvedPatchPath,
+      manifestFilePath: existsSync6(manifestFilePath) ? manifestFilePath : void 0,
+      patchFileName,
+      exists: false,
+      diffValid: false,
+      formatError: "Patch file does not exist."
+    };
+  }
+  const [patchContent, fileStats, manifest] = await Promise.all([
+    readFile3(resolvedPatchPath, "utf8"),
+    stat(resolvedPatchPath),
+    readManifest(manifestFilePath)
+  ]);
+  const format = validatePatchDiff(patchContent);
+  const derived = derivePatchMetadata(patchContent);
+  return {
+    patchFilePath: resolvedPatchPath,
+    manifestFilePath: manifest ? manifestFilePath : void 0,
+    patchFileName,
+    cveId: manifest?.cveId,
+    packageName: manifest?.packageName,
+    vulnerableVersion: manifest?.vulnerableVersion,
+    patchMode: manifest?.patchMode,
+    confidence: manifest?.confidence,
+    riskLevel: manifest?.riskLevel,
+    generatedAt: manifest?.generatedAt,
+    files: manifest?.files ?? derived.files,
+    hunkCount: manifest?.hunkCount ?? derived.hunkCount,
+    exists: true,
+    diffValid: format.valid,
+    formatError: format.error,
+    patchSizeBytes: fileStats.size,
+    lineCount: patchContent.split(/\r?\n/).length,
+    manifest
+  };
+}
+async function validatePatchArtifact(patchFilePath, options = {}) {
+  const inspection = await inspectPatchArtifact(patchFilePath, options);
+  const validationPhases = [
+    {
+      phase: "diff-format",
+      passed: inspection.diffValid,
+      error: inspection.diffValid ? void 0 : inspection.formatError,
+      message: inspection.diffValid ? "Patch content is a valid unified diff." : void 0
+    }
+  ];
+  if (!inspection.exists) {
+    return {
+      patchFilePath: inspection.patchFilePath,
+      manifestFilePath: inspection.manifestFilePath,
+      exists: false,
+      manifestFound: false,
+      diffValid: false,
+      formatError: inspection.formatError,
+      driftDetected: false,
+      validationPhases
+    };
+  }
+  const manifest = inspection.manifest;
+  const manifestFound = Boolean(manifest);
+  if (!manifest) {
+    validationPhases.push({
+      phase: "manifest-write",
+      passed: false,
+      error: "No patch manifest found for this patch artifact."
+    });
+    return {
+      patchFilePath: inspection.patchFilePath,
+      manifestFilePath: inspection.manifestFilePath,
+      exists: true,
+      manifestFound,
+      diffValid: inspection.diffValid,
+      formatError: inspection.formatError,
+      driftDetected: false,
+      validationPhases
+    };
+  }
+  validationPhases.push({
+    phase: "manifest-write",
+    passed: true,
+    message: "Patch manifest is present."
+  });
+  const cwd = options.cwd ?? process.cwd();
+  const packageManager = options.packageManager ?? detectPackageManager(cwd);
+  const inventory = await checkInventoryTool.execute({
+    cwd,
+    packageManager
+  });
+  if (inventory.error) {
+    validationPhases.push({
+      phase: "drift",
+      passed: false,
+      error: inventory.error
+    });
+    return {
+      patchFilePath: inspection.patchFilePath,
+      manifestFilePath: inspection.manifestFilePath,
+      exists: true,
+      manifestFound,
+      diffValid: inspection.diffValid,
+      formatError: inspection.formatError,
+      driftDetected: false,
+      cveId: manifest.cveId,
+      packageName: manifest.packageName,
+      vulnerableVersion: manifest.vulnerableVersion,
+      validationPhases
+    };
+  }
+  const matchingPackages = (inventory.packages ?? []).filter(
+    (pkg) => pkg.name === manifest.packageName
+  );
+  const installedVersion = matchingPackages[0]?.version;
+  const inventoryMatch = matchingPackages.some(
+    (pkg) => pkg.version === manifest.vulnerableVersion
+  );
+  const driftDetected = matchingPackages.length > 0 && !inventoryMatch;
+  validationPhases.push({
+    phase: "drift",
+    passed: !driftDetected,
+    message: matchingPackages.length === 0 ? `Package ${manifest.packageName} is not currently installed.` : inventoryMatch ? `Installed version matches manifest target ${manifest.vulnerableVersion}.` : `Installed version ${installedVersion} does not match manifest target ${manifest.vulnerableVersion}.`,
+    error: driftDetected ? "Patch manifest does not match the installed dependency version." : void 0
+  });
+  return {
+    patchFilePath: inspection.patchFilePath,
+    manifestFilePath: inspection.manifestFilePath,
+    exists: true,
+    manifestFound,
+    diffValid: inspection.diffValid,
+    formatError: inspection.formatError,
+    driftDetected,
+    cveId: manifest.cveId,
+    packageName: manifest.packageName,
+    vulnerableVersion: manifest.vulnerableVersion,
+    installedVersion,
+    inventoryMatch,
+    validationPhases
+  };
+}
+function resolvePatchesDir(cwd, patchesDir = DEFAULT_PATCHES_DIR) {
+  return isAbsolute(patchesDir) ? patchesDir : resolve(cwd, patchesDir);
+}
+function resolveArtifactPath(cwd, patchFilePath) {
+  return isAbsolute(patchFilePath) ? patchFilePath : resolve(cwd, patchFilePath);
+}
+async function readManifest(manifestFilePath) {
+  if (!existsSync6(manifestFilePath)) {
+    return void 0;
+  }
+  try {
+    const raw = await readFile3(manifestFilePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function derivePatchMetadata(patchContent) {
+  const files = Array.from(
+    new Set(
+      patchContent.split(/\r?\n/).filter((line) => line.startsWith("+++ b/")).map((line) => line.slice("+++ b/".length))
+    )
+  );
+  const hunkCount = patchContent.split(/\r?\n/).filter((line) => line.startsWith("@@ ")).length;
+  return { files, hunkCount };
+}
+function toSummary(inspection) {
+  return {
+    patchFilePath: inspection.patchFilePath,
+    manifestFilePath: inspection.manifestFilePath,
+    patchFileName: inspection.patchFileName,
+    cveId: inspection.cveId,
+    packageName: inspection.packageName,
+    vulnerableVersion: inspection.vulnerableVersion,
+    patchMode: inspection.patchMode,
+    confidence: inspection.confidence,
+    riskLevel: inspection.riskLevel,
+    generatedAt: inspection.generatedAt,
+    files: inspection.files,
+    hunkCount: inspection.hunkCount,
+    diffValid: inspection.diffValid
+  };
+}
+
 // src/platform/evidence.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync4 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function createEvidenceLog(cwd, cveIds, context = {}) {
   return {
     runId: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
@@ -2932,6 +3582,7 @@ function createEvidenceLog(cwd, cveIds, context = {}) {
     parentRunId: context.parentRunId,
     actor: context.actor,
     source: context.source,
+    llmProvider: context.llmProvider,
     idempotencyKey: context.idempotencyKey,
     cveIds,
     cwd,
@@ -2953,29 +3604,29 @@ function finalizeEvidence(log) {
   return log;
 }
 function writeEvidenceLog(cwd, log) {
-  const dir = join11(cwd, ".autoremediator", "evidence");
+  const dir = join12(cwd, ".autoremediator", "evidence");
   mkdirSync2(dir, { recursive: true });
-  const filePath = join11(dir, `${log.runId}.json`);
+  const filePath = join12(dir, `${log.runId}.json`);
   writeFileSync4(filePath, JSON.stringify(log, null, 2) + "\n", "utf8");
   return filePath;
 }
 
 // src/platform/idempotency.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { join as join13 } from "path";
 var DEFAULT_INDEX = {
   schemaVersion: "1.0",
   entries: {}
 };
 function indexFilePath(cwd) {
-  return join12(cwd, ".autoremediator", "state", "idempotency.json");
+  return join13(cwd, ".autoremediator", "state", "idempotency.json");
 }
 function entryKey(idempotencyKey, cveId) {
   return `${idempotencyKey}::${cveId.toUpperCase()}`;
 }
 function loadIndex(cwd) {
   const filePath = indexFilePath(cwd);
-  if (!existsSync6(filePath)) return DEFAULT_INDEX;
+  if (!existsSync7(filePath)) return DEFAULT_INDEX;
   try {
     const parsed = JSON.parse(readFileSync7(filePath, "utf8"));
     if (parsed && parsed.schemaVersion === "1.0" && parsed.entries) {
@@ -2988,7 +3639,7 @@ function loadIndex(cwd) {
 }
 function saveIndex(cwd, index) {
   const filePath = indexFilePath(cwd);
-  mkdirSync3(join12(cwd, ".autoremediator", "state"), { recursive: true });
+  mkdirSync3(join13(cwd, ".autoremediator", "state"), { recursive: true });
   writeFileSync5(filePath, JSON.stringify(index, null, 2) + "\n", "utf8");
 }
 function readIdempotentReport(cwd, idempotencyKey, cveId) {
@@ -3045,11 +3696,13 @@ async function remediate(cveId, options = {}) {
   const constraints = resolveConstraints(options, cwd);
   const provenance = resolveProvenanceContext(options);
   const correlation = resolveCorrelationContext(options);
+  const llmProvider = resolveProvider(options);
   const evidenceEnabled = options.evidence !== false;
   const evidence = evidenceEnabled ? createEvidenceLog(cwd, [normalizedCveId], {
     ...correlation,
     actor: provenance.actor,
     source: provenance.source,
+    llmProvider,
     idempotencyKey: options.idempotencyKey
   }) : void 0;
   if (options.resume && options.idempotencyKey) {
@@ -3078,7 +3731,8 @@ async function remediate(cveId, options = {}) {
       {
         cveId: normalizedCveId,
         dryRun: Boolean(options.dryRun),
-        preview: Boolean(options.preview)
+        preview: Boolean(options.preview),
+        llmProvider
       },
       {
         directDependenciesOnly: Boolean(constraints.directDependenciesOnly),
@@ -3126,7 +3780,8 @@ async function remediate(cveId, options = {}) {
       { cveId: normalizedCveId },
       {
         resultCount: report.results.length,
-        vulnerableCount: report.vulnerablePackages.length
+        vulnerableCount: report.vulnerablePackages.length,
+        llmUsage: report.llmUsage
       }
     );
     finalizeEvidence(evidence);
@@ -3409,6 +4064,7 @@ async function remediateFromScan(inputPath, options = {}) {
   const findings = parseScanInput(inputPath, format);
   const cveIds = uniqueCveIds(findings);
   const policy = loadPolicy(cwd, options.policy);
+  const llmProvider = resolveProvider(options);
   const correlation = resolveCorrelationContext(options);
   const provenance = resolveProvenanceContext(options);
   const constraints = resolveConstraints(options, cwd);
@@ -3416,6 +4072,7 @@ async function remediateFromScan(inputPath, options = {}) {
     ...correlation,
     actor: provenance.actor,
     source: provenance.source,
+    llmProvider,
     idempotencyKey: options.idempotencyKey
   });
   addEvidenceStep(evidence, "scan.parse", { inputPath, format }, { findingCount: findings.length, cveCount: cveIds.length });
@@ -3433,6 +4090,16 @@ async function remediateFromScan(inputPath, options = {}) {
   const errors = execution.errors;
   const patchCount = execution.patchCount;
   const patchValidationFailures = execution.patchValidationFailures;
+  let llmUsageCount = 0;
+  let estimatedCostUsd = 0;
+  let totalLlmLatencyMs = 0;
+  for (const report of reports) {
+    for (const usage of report.llmUsage ?? []) {
+      llmUsageCount += 1;
+      estimatedCostUsd += usage.estimatedCostUsd ?? 0;
+      totalLlmLatencyMs += usage.latencyMs ?? 0;
+    }
+  }
   const outcome = buildScanOutcome({ reports, errors });
   const { status, successCount, failedCount, strategyCounts, dependencyScopeCounts, unresolvedByReason, remediationCount } = outcome;
   evidence.summary = {
@@ -3446,7 +4113,10 @@ async function remediateFromScan(inputPath, options = {}) {
     strategyCounts,
     dependencyScopeCounts,
     unresolvedByReason,
-    patchesDir: patchCount > 0 ? patchesDir : void 0
+    patchesDir: patchCount > 0 ? patchesDir : void 0,
+    llmUsageCount: llmUsageCount > 0 ? llmUsageCount : void 0,
+    estimatedCostUsd: llmUsageCount > 0 ? Number(estimatedCostUsd.toFixed(6)) : void 0,
+    totalLlmLatencyMs: llmUsageCount > 0 ? totalLlmLatencyMs : void 0
   };
   finalizeEvidence(evidence);
   const evidenceFile = options.evidence === false ? void 0 : writeEvidenceLog(cwd, evidence);
@@ -3469,7 +4139,10 @@ async function remediateFromScan(inputPath, options = {}) {
     correlation,
     provenance,
     constraints,
-    idempotencyKey: options.idempotencyKey
+    idempotencyKey: options.idempotencyKey,
+    llmUsageCount: llmUsageCount > 0 ? llmUsageCount : void 0,
+    estimatedCostUsd: llmUsageCount > 0 ? Number(estimatedCostUsd.toFixed(6)) : void 0,
+    totalLlmLatencyMs: llmUsageCount > 0 ? totalLlmLatencyMs : void 0
   };
 }
 
@@ -3486,8 +4159,11 @@ export {
   toCiSummary,
   ciExitCode,
   toSarifOutput,
+  listPatchArtifacts,
+  inspectPatchArtifact,
+  validatePatchArtifact,
   remediate,
   planRemediation,
   remediateFromScan
 };
-//# sourceMappingURL=chunk-MUFP2DQX.js.map
+//# sourceMappingURL=chunk-5S4Y3WVZ.js.map