patchwarden 0.4.0 → 0.6.0

package/dist/assessments/agentAssessor.d.ts

@@ -0,0 +1,15 @@
+import { PatchWardenConfig } from "../config.js";
+import type { AgentAssessmentSummary } from "./assessmentStore.js";
+export interface AgentAssessorInput {
+    assessmentId: string;
+    assessmentDir: string;
+    agentName: string;
+    repoPath: string;
+    workspaceRoot: string;
+    goal: string;
+    planContent: string;
+    timeoutSeconds: number;
+    maxOutputBytes: number;
+    config: PatchWardenConfig;
+}
+export declare function runAgentAssessment(input: AgentAssessorInput): AgentAssessmentSummary;

package/dist/assessments/agentAssessor.js

@@ -0,0 +1,293 @@
+import { writeFileSync } from "node:fs";
+import { resolve, relative, isAbsolute } from "node:path";
+import { buildAgentInvocation, buildAssessmentPrompt } from "../runner/agentInvocation.js";
+import { runSimpleProcessSync } from "../runner/simpleProcess.js";
+import { captureRepoSnapshot, compareSnapshots } from "../runner/changeCapture.js";
+const ASSESSMENT_MARKER = "===ASSESSMENT_JSON===";
+export function runAgentAssessment(input) {
+    const logPaths = {
+        stdout: resolve(input.assessmentDir, "agent-assessment-stdout.log"),
+        stderr: resolve(input.assessmentDir, "agent-assessment-stderr.log"),
+        assessment: resolve(input.assessmentDir, "agent-assessment.json"),
+    };
+    const emptySummary = {
+        attempted: false,
+        status: "not_run",
+        output: null,
+        merged_risk: "low",
+        merged_decision: "allow",
+        merged_reason_codes: [],
+        timed_out: false,
+        exit_code: null,
+        read_only_violation: false,
+        violation_files: [],
+        stdout_truncated: false,
+        stderr_truncated: false,
+        log_paths: logPaths,
+    };
+    // ── 1. Build prompt and write to file for {prompt_file} support ──
+    const assessmentPrompt = buildAssessmentPrompt(input.goal, input.planContent, input.repoPath);
+    const promptFilePath = resolve(input.assessmentDir, "agent-assessment-prompt.md");
+    writeFileSync(promptFilePath, assessmentPrompt, "utf-8");
+    logPaths.prompt = promptFilePath;
+    // ── 2. Before snapshot (repo-scoped) ──
+    let repoBefore;
+    try {
+        repoBefore = captureRepoSnapshot(input.repoPath);
+    }
+    catch {
+        // If we can't capture before snapshot, conservatively skip agent assessment
+        emptySummary.status = "spawn_failed";
+        emptySummary.merged_risk = "medium";
+        emptySummary.merged_decision = "needs_confirm";
+        emptySummary.merged_reason_codes = ["agent_assessment_snapshot_failed"];
+        writeSummary(logPaths.assessment, emptySummary);
+        return emptySummary;
+    }
+    // ── 3. Build agent invocation ──
+    let invocation;
+    try {
+        invocation = buildAgentInvocation(input.agentName, input.repoPath, assessmentPrompt, input.config, promptFilePath);
+    }
+    catch (error) {
+        emptySummary.status = "spawn_failed";
+        emptySummary.merged_risk = "medium";
+        emptySummary.merged_decision = "needs_confirm";
+        emptySummary.merged_reason_codes = ["agent_assessment_invocation_failed"];
+        writeSummary(logPaths.assessment, emptySummary);
+        return emptySummary;
+    }
+    emptySummary.attempted = true;
+    // ── 4. Run agent ──
+    const result = runSimpleProcessSync({
+        command: invocation.command,
+        args: invocation.args,
+        cwd: input.repoPath,
+        timeoutMs: input.timeoutSeconds * 1000,
+        maxStdoutBytes: input.maxOutputBytes,
+        maxStderrBytes: Math.max(16384, Math.floor(input.maxOutputBytes / 4)),
+        stdoutPath: logPaths.stdout,
+        stderrPath: logPaths.stderr,
+    });
+    // ── 5. After snapshot + read-only violation check ──
+    let readOnlyViolation = false;
+    let violationFiles = [];
+    try {
+        const repoAfter = captureRepoSnapshot(input.repoPath);
+        const changes = compareSnapshots(repoBefore, repoAfter);
+        if (changes.length > 0) {
+            readOnlyViolation = true;
+            violationFiles = changes.map((c) => c.path);
+        }
+    }
+    catch {
+        // 修复 #4: after snapshot 捕获失败 → 保守变为 high / blocked
+        readOnlyViolation = true;
+        violationFiles = ["(after snapshot capture failed)"];
+    }
+    if (readOnlyViolation) {
+        const summary = {
+            attempted: true,
+            status: "read_only_violation",
+            output: null,
+            merged_risk: "high",
+            merged_decision: "blocked",
+            merged_reason_codes: ["agent_read_only_violation"],
+            timed_out: false,
+            exit_code: result.exitCode,
+            read_only_violation: true,
+            violation_files: violationFiles,
+            stdout_truncated: result.stdoutTruncated,
+            stderr_truncated: result.stderrTruncated,
+            log_paths: { ...logPaths, violation: resolve(input.assessmentDir, "agent-assessment-violation.json") },
+        };
+        writeFileSync(summary.log_paths.violation, JSON.stringify({
+            violation: "read_only_violation",
+            files: violationFiles,
+            exit_code: result.exitCode,
+        }, null, 2), "utf-8");
+        writeSummary(logPaths.assessment, summary);
+        return summary;
+    }
+    // ── 6. Handle spawn failure ──
+    if (result.spawnError) {
+        const summary = {
+            ...emptySummary,
+            attempted: true,
+            status: "spawn_failed",
+            merged_risk: "medium",
+            merged_decision: "needs_confirm",
+            merged_reason_codes: ["agent_assessment_spawn_failed"],
+            exit_code: result.exitCode,
+            stdout_truncated: result.stdoutTruncated,
+            stderr_truncated: result.stderrTruncated,
+        };
+        writeSummary(logPaths.assessment, summary);
+        return summary;
+    }
+    // ── 7. Handle timeout ──
+    if (result.timedOut) {
+        const summary = {
+            ...emptySummary,
+            attempted: true,
+            status: "timed_out",
+            merged_risk: "medium",
+            merged_decision: "needs_confirm",
+            merged_reason_codes: ["agent_assessment_timed_out"],
+            timed_out: true,
+            exit_code: result.exitCode,
+            stdout_truncated: result.stdoutTruncated,
+            stderr_truncated: result.stderrTruncated,
+        };
+        writeSummary(logPaths.assessment, summary);
+        return summary;
+    }
+    // ── 8. Handle non-zero exit ──
+    if (result.exitCode !== 0) {
+        const summary = {
+            ...emptySummary,
+            attempted: true,
+            status: "non_zero_exit",
+            merged_risk: "medium",
+            merged_decision: "needs_confirm",
+            merged_reason_codes: ["agent_assessment_non_zero_exit"],
+            exit_code: result.exitCode,
+            stdout_truncated: result.stdoutTruncated,
+            stderr_truncated: result.stderrTruncated,
+        };
+        writeSummary(logPaths.assessment, summary);
+        return summary;
+    }
+    // ── 9. Parse JSON from stdout ──
+    const parsed = parseAssessmentJson(result.stdout, input.repoPath);
+    if (!parsed.output) {
+        const summary = {
+            ...emptySummary,
+            attempted: true,
+            status: "parse_failed",
+            merged_risk: "medium",
+            merged_decision: "needs_confirm",
+            merged_reason_codes: ["agent_assessment_parse_failed", ...parsed.sanitized_reasons],
+            exit_code: result.exitCode,
+            stdout_truncated: result.stdoutTruncated,
+            stderr_truncated: result.stderrTruncated,
+        };
+        writeSummary(logPaths.assessment, summary);
+        return summary;
+    }
+    // ── 10. Merge risk (agent can only raise, not lower) ──
+    const agentRisk = parsed.output.risk_level;
+    let mergedRisk = agentRisk === "high" ? "high" : agentRisk === "medium" ? "medium" : "low";
+    let mergedDecision = mergedRisk === "high" ? "blocked" : mergedRisk === "medium" ? "needs_confirm" : "allow";
+    const mergedReasonCodes = ["agent_assessment_completed", ...parsed.sanitized_reasons];
+    // 修复 #5: agent requires_user_confirm=true 时至少升级为 medium / needs_confirm
+    if (parsed.output.requires_user_confirm && mergedRisk === "low") {
+        mergedRisk = "medium";
+        mergedDecision = "needs_confirm";
+        mergedReasonCodes.push("agent_requested_confirm");
+    }
+    const summary = {
+        attempted: true,
+        status: "completed",
+        output: { ...parsed.output, assessed_at: new Date().toISOString() },
+        merged_risk: mergedRisk,
+        merged_decision: mergedDecision,
+        merged_reason_codes: mergedReasonCodes,
+        timed_out: false,
+        exit_code: result.exitCode,
+        read_only_violation: false,
+        violation_files: [],
+        stdout_truncated: result.stdoutTruncated,
+        stderr_truncated: result.stderrTruncated,
+        log_paths: logPaths,
+    };
+    writeSummary(logPaths.assessment, summary);
+    return summary;
+}
+function parseAssessmentJson(stdout, repoPath) {
+    const sanitized_reasons = [];
+    // Use the LAST marker only
+    const lastMarkerIndex = stdout.lastIndexOf(ASSESSMENT_MARKER);
+    if (lastMarkerIndex < 0)
+        return { output: null, sanitized_reasons };
+    const jsonText = stdout.slice(lastMarkerIndex + ASSESSMENT_MARKER.length).trim();
+    // Find the JSON object (from first { to last })
+    const jsonStart = jsonText.indexOf("{");
+    const jsonEnd = jsonText.lastIndexOf("}");
+    if (jsonStart < 0 || jsonEnd < 0 || jsonEnd <= jsonStart)
+        return { output: null, sanitized_reasons };
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText.slice(jsonStart, jsonEnd + 1));
+    }
+    catch {
+        return { output: null, sanitized_reasons };
+    }
+    // ── Strict validation ──
+    if (parsed.risk_level !== "low" && parsed.risk_level !== "medium" && parsed.risk_level !== "high") {
+        return { output: null, sanitized_reasons };
+    }
+    const confidence = Number(parsed.confidence);
+    if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+        return { output: null, sanitized_reasons };
+    }
+    if (!Array.isArray(parsed.reason_codes))
+        return { output: null, sanitized_reasons };
+    if (parsed.reason_codes.length > 50)
+        return { output: null, sanitized_reasons };
+    const reasonCodes = parsed.reason_codes.filter((r) => typeof r === "string" && r.length <= 100);
+    if (reasonCodes.length !== parsed.reason_codes.length) {
+        sanitized_reasons.push("reason_codes_filtered");
+    }
+    if (!Array.isArray(parsed.affected_paths))
+        return { output: null, sanitized_reasons };
+    if (parsed.affected_paths.length > 100)
+        return { output: null, sanitized_reasons };
+    const affectedPaths = [];
+    let pathsSanitized = false;
+    for (const p of parsed.affected_paths) {
+        if (typeof p !== "string") {
+            pathsSanitized = true;
+            continue;
+        }
+        // Must be relative, not absolute, and within repo
+        if (isAbsolute(p)) {
+            pathsSanitized = true;
+            continue;
+        }
+        const resolved = resolve(repoPath, p);
+        const rel = relative(repoPath, resolved);
+        if (rel.startsWith("..")) {
+            pathsSanitized = true;
+            continue;
+        }
+        affectedPaths.push(p);
+    }
+    if (pathsSanitized) {
+        sanitized_reasons.push("paths_sanitized");
+    }
+    if (!Array.isArray(parsed.destructive_actions))
+        return { output: null, sanitized_reasons };
+    if (parsed.destructive_actions.length > 20)
+        return { output: null, sanitized_reasons };
+    const destructiveActions = parsed.destructive_actions.filter((d) => typeof d === "string" && d.length <= 200);
+    if (typeof parsed.requires_user_confirm !== "boolean")
+        return { output: null, sanitized_reasons };
+    const notes = typeof parsed.notes === "string" ? parsed.notes.slice(0, 2000) : "";
+    return {
+        output: {
+            risk_level: parsed.risk_level,
+            reason_codes: reasonCodes,
+            affected_paths: affectedPaths,
+            destructive_actions: destructiveActions,
+            requires_user_confirm: parsed.requires_user_confirm,
+            confidence,
+            notes,
+            assessed_at: new Date().toISOString(),
+        },
+        sanitized_reasons,
+    };
+}
+function writeSummary(path, summary) {
+    writeFileSync(path, JSON.stringify(summary, null, 2), "utf-8");
+}

package/dist/assessments/assessmentStore.d.ts

@@ -0,0 +1,133 @@
+import { type RepoSnapshot } from "../runner/changeCapture.js";
+import type { RiskAssessmentResult } from "../security/riskEngine.js";
+import type { TaskTemplateName, ChangePolicy } from "../tools/taskTemplates.js";
+export interface AgentAssessmentSummary {
+    attempted: boolean;
+    status: "completed" | "timed_out" | "non_zero_exit" | "parse_failed" | "read_only_violation" | "spawn_failed" | "not_run";
+    output: AgentAssessmentOutput | null;
+    merged_risk: "low" | "medium" | "high";
+    merged_decision: "allow" | "needs_confirm" | "blocked";
+    merged_reason_codes: string[];
+    timed_out: boolean;
+    exit_code: number | null;
+    read_only_violation: boolean;
+    violation_files: string[];
+    stdout_truncated: boolean;
+    stderr_truncated: boolean;
+    log_paths: {
+        stdout: string;
+        stderr: string;
+        assessment: string;
+        prompt?: string;
+        violation?: string;
+    };
+}
+export interface AgentAssessmentOutput {
+    risk_level: "low" | "medium" | "high";
+    reason_codes: string[];
+    affected_paths: string[];
+    destructive_actions: string[];
+    requires_user_confirm: boolean;
+    confidence: number;
+    notes: string;
+    assessed_at: string;
+}
+export interface AssessmentRecord {
+    assessment_id: string;
+    assessment_short_id: string;
+    decision: "allow" | "needs_confirm" | "blocked";
+    risk_level: "low" | "medium" | "high";
+    risk_hints: string[];
+    hard_rule_hits: string[];
+    reason_codes: string[];
+    plan_hash: string | null;
+    plan_id: string | null;
+    policy_hash: string;
+    tool_manifest_sha256: string;
+    workspace_fingerprint: string;
+    workspace_snapshot_summary: {
+        head: string | null;
+        file_count: number;
+        workspace_dirty: boolean;
+        snapshot_truncated: boolean;
+    };
+    expires_at: string;
+    created_at: string;
+    repo_path: string;
+    resolved_repo_path: string;
+    template?: TaskTemplateName | null;
+    goal?: string | null;
+    test_command?: string | null;
+    verify_commands?: string[];
+    agent: string;
+    timeout_seconds?: number;
+    change_policy?: ChangePolicy;
+    requires_confirm: boolean;
+    confirmed: boolean;
+    confirmed_at: string | null;
+    confirm_code: string | null;
+    agent_assessment_summary?: AgentAssessmentSummary | null;
+}
+export interface AssessmentCreateInput {
+    decision: RiskAssessmentResult["decision"];
+    risk_level: RiskAssessmentResult["risk_level"];
+    risk_hints: string[];
+    hard_rule_hits: string[];
+    reason_codes: string[];
+    repo_path: string;
+    resolved_repo_path: string;
+    plan_id: string | null;
+    plan_content: string | null;
+    template?: TaskTemplateName | null;
+    goal?: string | null;
+    test_command?: string | null;
+    verify_commands?: string[];
+    agent: string;
+    timeout_seconds?: number;
+    change_policy?: ChangePolicy;
+    snapshot: RepoSnapshot;
+    assessment_id?: string;
+    assessment_dir?: string;
+    agent_assessment_summary?: AgentAssessmentSummary | null;
+}
+export interface AssessmentValidationResult {
+    valid: boolean;
+    failure_reason: string | null;
+    assessment: AssessmentRecord | null;
+}
+export interface AssessmentConfirmationResult {
+    assessment_id: string;
+    decision: "needs_confirm";
+    confirmed: true;
+    confirmed_at: string;
+    expires_at: string;
+    next_action: string;
+}
+interface AssessmentValidationOptions {
+    allow_unconfirmed?: boolean;
+    skip_tool_manifest?: boolean;
+}
+export declare function generateAssessmentId(): string;
+export declare function createAssessmentDir(assessmentId: string): string;
+export declare function createAssessment(input: AssessmentCreateInput): AssessmentRecord;
+export declare function readAssessment(assessmentId: string): AssessmentRecord;
+export declare function validateAssessmentFreshness(assessmentId: string, currentSnapshot: RepoSnapshot, options?: AssessmentValidationOptions): AssessmentValidationResult;
+/**
+ * Records an explicit confirmation performed from the local PatchWarden CLI.
+ * This is intentionally not registered as an MCP tool: a remote client may
+ * request confirmation, but it cannot grant confirmation to itself.
+ */
+export declare function confirmAssessment(assessmentId: string): AssessmentConfirmationResult;
+export declare function computeWorkspaceFingerprint(snapshot: RepoSnapshot): string;
+interface PolicyHashInput {
+    change_policy: ChangePolicy;
+    template: TaskTemplateName | null;
+    verify_commands: string[];
+    allowed_test_commands: string[];
+    repo_allowed_test_commands: string[];
+    sensitive_path_rules: string;
+    artifact_rules: string;
+    schema_epoch: string;
+}
+export declare function computePolicyHash(input: PolicyHashInput): string;
+export {};

package/dist/assessments/assessmentStore.js

@@ -0,0 +1,238 @@
+import { mkdirSync, writeFileSync, existsSync, readFileSync, renameSync, } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { resolve, join } from "node:path";
+import { getAssessmentsDir, getConfig, getRepoAllowedTestCommands } from "../config.js";
+import { guardPath } from "../security/pathGuard.js";
+import { PatchWardenError } from "../errors.js";
+import { TOOL_SCHEMA_EPOCH } from "../version.js";
+import { getLastToolCatalogSnapshot } from "../tools/toolCatalog.js";
+import { captureRepoSnapshot } from "../runner/changeCapture.js";
+const SENSITIVE_PATH_RULES_SIGNATURE = "v1";
+const ARTIFACT_RULES_SIGNATURE = "v1";
+export function generateAssessmentId() {
+    const timestamp = new Date().toISOString().replace(/[-:]/g, "").replace("T", "_").slice(0, 15);
+    const randomHex = randomBytes(16).toString("hex");
+    return `assessment_${timestamp}_${randomHex}`;
+}
+export function createAssessmentDir(assessmentId) {
+    const config = getConfig();
+    const assessmentsDir = getAssessmentsDir(config);
+    guardPath(assessmentsDir, config.workspaceRoot, config.assessmentsDir);
+    mkdirSync(assessmentsDir, { recursive: true });
+    const dir = resolve(assessmentsDir, assessmentId);
+    guardPath(dir, config.workspaceRoot, config.assessmentsDir);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function createAssessment(input) {
+    const config = getConfig();
+    const assessmentId = input.assessment_id || generateAssessmentId();
+    const randomHex = assessmentId.split("_").pop() || "";
+    const dir = input.assessment_dir || createAssessmentDir(assessmentId);
+    const planHash = input.plan_content
+        ? createHash("sha256").update(input.plan_content).digest("hex")
+        : null;
+    const toolManifest = getLastToolCatalogSnapshot()?.tool_manifest_sha256 || computeFallbackManifestHash(config);
+    const workspaceFingerprint = computeWorkspaceFingerprint(input.snapshot);
+    const snapshotTruncated = input.snapshot.warnings.some((w) => w.includes("snapshot limited"));
+    const policyHash = computePolicyHash({
+        change_policy: input.change_policy || "repo_scoped_changes",
+        template: input.template || null,
+        verify_commands: input.verify_commands || [],
+        allowed_test_commands: config.allowedTestCommands,
+        repo_allowed_test_commands: getRepoAllowedCommands(config, input.resolved_repo_path),
+        sensitive_path_rules: SENSITIVE_PATH_RULES_SIGNATURE,
+        artifact_rules: ARTIFACT_RULES_SIGNATURE,
+        schema_epoch: TOOL_SCHEMA_EPOCH,
+    });
+    const now = new Date();
+    const expiresAt = new Date(now.getTime() + config.assessmentTtlSeconds * 1000).toISOString();
+    const record = {
+        assessment_id: assessmentId,
+        assessment_short_id: randomHex.slice(0, 12),
+        decision: input.decision,
+        risk_level: input.risk_level,
+        risk_hints: input.risk_hints,
+        hard_rule_hits: input.hard_rule_hits,
+        reason_codes: input.reason_codes,
+        plan_hash: planHash,
+        plan_id: input.plan_id,
+        policy_hash: policyHash,
+        tool_manifest_sha256: toolManifest,
+        workspace_fingerprint: workspaceFingerprint,
+        workspace_snapshot_summary: {
+            head: input.snapshot.head,
+            file_count: Object.keys(input.snapshot.files).length,
+            workspace_dirty: input.snapshot.workspace_dirty,
+            snapshot_truncated: snapshotTruncated,
+        },
+        expires_at: expiresAt,
+        created_at: now.toISOString(),
+        repo_path: input.repo_path,
+        resolved_repo_path: input.resolved_repo_path,
+        template: input.template || null,
+        goal: input.goal || null,
+        test_command: input.test_command || null,
+        verify_commands: input.verify_commands || [],
+        agent: input.agent,
+        timeout_seconds: input.timeout_seconds,
+        change_policy: input.change_policy || "repo_scoped_changes",
+        requires_confirm: input.decision === "needs_confirm",
+        confirmed: false,
+        confirmed_at: null,
+        confirm_code: null,
+        agent_assessment_summary: input.agent_assessment_summary || null,
+    };
+    writeFileSync(join(dir, "assessment.json"), JSON.stringify(record, null, 2), "utf-8");
+    return record;
+}
+export function readAssessment(assessmentId) {
+    const config = getConfig();
+    const assessmentsDir = getAssessmentsDir(config);
+    const dir = resolve(assessmentsDir, assessmentId);
+    const file = join(dir, "assessment.json");
+    guardPath(file, config.workspaceRoot, config.assessmentsDir);
+    if (!existsSync(file)) {
+        throw new PatchWardenError("assessment_not_found", `Assessment "${assessmentId}" not found.`, "Call create_task with execution_mode=assess_only first to get a valid assessment_id.", true, { assessment_id: assessmentId });
+    }
+    return JSON.parse(readFileSync(file, "utf-8"));
+}
+export function validateAssessmentFreshness(assessmentId, currentSnapshot, options = {}) {
+    let assessment;
+    try {
+        assessment = readAssessment(assessmentId);
+    }
+    catch (e) {
+        return { valid: false, failure_reason: extractReason(e), assessment: null };
+    }
+    if (new Date(assessment.expires_at) < new Date()) {
+        return { valid: false, failure_reason: "assessment_expired", assessment };
+    }
+    if (assessment.plan_id && assessment.plan_hash) {
+        const config = getConfig();
+        const planFile = resolve(config.workspaceRoot, config.plansDir, assessment.plan_id, "plan.md");
+        if (!existsSync(planFile)) {
+            return { valid: false, failure_reason: "assessment_plan_file_missing", assessment };
+        }
+        const currentPlanHash = createHash("sha256")
+            .update(readFileSync(planFile, "utf-8"))
+            .digest("hex");
+        if (currentPlanHash !== assessment.plan_hash) {
+            return { valid: false, failure_reason: "assessment_stale_plan", assessment };
+        }
+    }
+    if (!options.skip_tool_manifest) {
+        const currentManifest = getLastToolCatalogSnapshot()?.tool_manifest_sha256 ||
+            computeFallbackManifestHash(getConfig());
+        if (currentManifest !== assessment.tool_manifest_sha256) {
+            return { valid: false, failure_reason: "assessment_stale_config", assessment };
+        }
+    }
+    const currentFingerprint = computeWorkspaceFingerprint(currentSnapshot);
+    if (currentFingerprint !== assessment.workspace_fingerprint) {
+        return { valid: false, failure_reason: "assessment_workspace_changed", assessment };
+    }
+    const config = getConfig();
+    const currentPolicyHash = computePolicyHash({
+        change_policy: assessment.change_policy || "repo_scoped_changes",
+        template: assessment.template || null,
+        verify_commands: assessment.verify_commands || [],
+        allowed_test_commands: config.allowedTestCommands,
+        repo_allowed_test_commands: getRepoAllowedCommands(config, assessment.resolved_repo_path),
+        sensitive_path_rules: SENSITIVE_PATH_RULES_SIGNATURE,
+        artifact_rules: ARTIFACT_RULES_SIGNATURE,
+        schema_epoch: TOOL_SCHEMA_EPOCH,
+    });
+    if (currentPolicyHash !== assessment.policy_hash) {
+        return { valid: false, failure_reason: "assessment_stale_policy", assessment };
+    }
+    if (assessment.requires_confirm && !assessment.confirmed && !options.allow_unconfirmed) {
+        return { valid: false, failure_reason: "assessment_needs_confirm", assessment };
+    }
+    return { valid: true, failure_reason: null, assessment };
+}
+/**
+ * Records an explicit confirmation performed from the local PatchWarden CLI.
+ * This is intentionally not registered as an MCP tool: a remote client may
+ * request confirmation, but it cannot grant confirmation to itself.
+ */
+export function confirmAssessment(assessmentId) {
+    if (!/^assessment_\d{8}_\d{6}_[0-9a-f]{32}$/.test(assessmentId)) {
+        throw new PatchWardenError("assessment_id_invalid", "Local confirmation requires the full assessment_id (32 hexadecimal random characters).", "Copy the complete assessment_id from the assess_only response; assessment_short_id is display-only.");
+    }
+    const assessment = readAssessment(assessmentId);
+    if (assessment.decision !== "needs_confirm" || !assessment.requires_confirm) {
+        throw new PatchWardenError("assessment_confirmation_not_allowed", `Assessment "${assessmentId}" has decision "${assessment.decision}" and cannot be locally confirmed.`, assessment.decision === "blocked"
+            ? "Fix the hard-rule finding and run assess_only again."
+            : "This assessment does not require confirmation; execute it with the minimal assessment_id call.");
+    }
+    const snapshot = captureRepoSnapshot(assessment.resolved_repo_path);
+    const validation = validateAssessmentFreshness(assessmentId, snapshot, {
+        allow_unconfirmed: true,
+        // A standalone CLI has no active MCP profile snapshot. The execute path
+        // still performs the full tool-manifest check before creating the task.
+        skip_tool_manifest: true,
+    });
+    if (!validation.valid || !validation.assessment) {
+        throw new PatchWardenError(validation.failure_reason || "assessment_validation_failed", `Assessment "${assessmentId}" cannot be confirmed: ${validation.failure_reason || "validation_failed"}.`, "Run create_task with execution_mode=assess_only again, then confirm the new assessment locally.");
+    }
+    const confirmedAt = validation.assessment.confirmed_at || new Date().toISOString();
+    const confirmedRecord = {
+        ...validation.assessment,
+        confirmed: true,
+        confirmed_at: confirmedAt,
+        confirm_code: validation.assessment.confirm_code || randomBytes(8).toString("hex"),
+    };
+    const config = getConfig();
+    const assessmentFile = resolve(getAssessmentsDir(config), assessmentId, "assessment.json");
+    guardPath(assessmentFile, config.workspaceRoot, config.assessmentsDir);
+    const temporaryFile = `${assessmentFile}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    guardPath(temporaryFile, config.workspaceRoot, config.assessmentsDir);
+    writeFileSync(temporaryFile, JSON.stringify(confirmedRecord, null, 2), "utf-8");
+    renameSync(temporaryFile, assessmentFile);
+    return {
+        assessment_id: assessmentId,
+        decision: "needs_confirm",
+        confirmed: true,
+        confirmed_at: confirmedAt,
+        expires_at: confirmedRecord.expires_at,
+        next_action: "Call create_task with only execution_mode=execute and this full assessment_id.",
+    };
+}
+export function computeWorkspaceFingerprint(snapshot) {
+    const fileHashes = Object.entries(snapshot.files)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([path, fp]) => `${path}:${fp.sha256}`)
+        .join("\n");
+    return createHash("sha256")
+        .update(`${snapshot.head || "null"}\n${snapshot.status}\n${fileHashes}`)
+        .digest("hex");
+}
+export function computePolicyHash(input) {
+    const payload = JSON.stringify({
+        change_policy: input.change_policy,
+        template: input.template,
+        verify_commands: [...input.verify_commands].sort(),
+        allowed_test_commands: [...input.allowed_test_commands].sort(),
+        repo_allowed_test_commands: [...input.repo_allowed_test_commands].sort(),
+        sensitive_path_rules: input.sensitive_path_rules,
+        artifact_rules: input.artifact_rules,
+        schema_epoch: input.schema_epoch,
+    });
+    return createHash("sha256").update(payload).digest("hex");
+}
+function getRepoAllowedCommands(config, repoPath) {
+    return getRepoAllowedTestCommands(config, repoPath);
+}
+function computeFallbackManifestHash(config) {
+    return createHash("sha256")
+        .update(`${TOOL_SCHEMA_EPOCH}:${config.toolProfile || "full"}`)
+        .digest("hex");
+}
+function extractReason(error) {
+    if (error instanceof PatchWardenError)
+        return error.reason;
+    if (error instanceof Error)
+        return error.message.slice(0, 80);
+    return String(error).slice(0, 80);
+}