patchwarden 0.6.4 → 1.5.0

package/dist/tools/auditTask.js

@@ -1,8 +1,11 @@
-import { readFileSync, existsSync, writeFileSync, readdirSync } from "node:fs";
-import { join, resolve, relative } from "node:path";
+// @ts-nocheck
+import { readFileSync, existsSync, writeFileSync, readdirSync, statSync } from "node:fs";
+import { join, resolve, relative, basename, sep, isAbsolute } from "node:path";
 import { getTasksDir, getConfig } from "../config.js";
 import { guardReadPath, guardWorkspacePath } from "../security/pathGuard.js";
-import { guardSensitivePath } from "../security/sensitiveGuard.js";
+import { guardSensitivePath, isSensitivePath } from "../security/sensitiveGuard.js";
+import { evaluateAcceptance } from "../goal/acceptanceEngine.js";
+import { renderAcceptanceMarkdown } from "../goal/acceptanceTemplate.js";
 // Release claim patterns — anything that claims remote publish/release/deploy
 const RELEASE_PATTERNS = [
     /npm\s+package\s+version\s+published/i,
@@ -42,6 +45,361 @@ function findMdFiles(dir, maxDepth = 3) {
     catch { /* skip unreadable dirs */ }
     return results;
 }
+// ── v0.7.2: New audit checks (exported for testing) ────────────────
+/**
+ * Convert a glob pattern (supporting `**` and `*`) into a RegExp.
+ * `**` matches any number of path segments (including zero);
+ * `*` matches a single path segment (no `/`).
+ * Path separators in the pattern are expected to be `/`.
+ */
+function globToRegExp(pattern) {
+    // Normalize backslashes to forward slashes for matching consistency.
+    const normalized = pattern.replace(/\\/g, "/");
+    let re = "^";
+    for (let i = 0; i < normalized.length; i++) {
+        const ch = normalized[i];
+        if (ch === "*") {
+            if (normalized[i + 1] === "*") {
+                // Consume the second '*' (and an optional following '/')
+                i++;
+                if (normalized[i + 1] === "/") {
+                    i++;
+                    // `**/` matches zero or more leading segments, or nothing.
+                    re += "(?:.*/)?";
+                }
+                else {
+                    // `**` at end or without trailing slash — match anything.
+                    re += ".*";
+                }
+            }
+            else {
+                // Single `*` matches one segment (no `/`).
+                re += "[^/]*";
+            }
+        }
+        else if ("/.+^$(){}|[]\\".includes(ch)) {
+            re += "\\" + ch;
+        }
+        else {
+            re += ch;
+        }
+    }
+    re += "$";
+    return new RegExp(re);
+}
+/**
+ * Check 1: forbidden_scope_violation (fail level).
+ * Returns null when no forbidden patterns are configured (skip).
+ * Returns pass when changed files do not match any forbidden pattern.
+ * Returns fail when any changed file path (or old_path) matches a forbidden glob.
+ */
+export function checkForbiddenScope(changedFiles, forbidden) {
+    if (!forbidden || forbidden.length === 0)
+        return null;
+    if (changedFiles.length === 0) {
+        return { name: "forbidden_scope_violation", result: "pass", detail: "No forbidden path violations." };
+    }
+    const patterns = forbidden.map((p) => globToRegExp(p));
+    const hits = [];
+    for (const file of changedFiles) {
+        const candidates = [file.path];
+        if (file.old_path)
+            candidates.push(file.old_path);
+        for (const candidate of candidates) {
+            const normalized = candidate.replace(/\\/g, "/");
+            if (patterns.some((re) => re.test(normalized))) {
+                hits.push(normalized);
+            }
+        }
+    }
+    if (hits.length > 0) {
+        return {
+            name: "forbidden_scope_violation",
+            result: "fail",
+            detail: `Changed files hit forbidden paths: ${[...new Set(hits)].join(", ")}`,
+        };
+    }
+    return { name: "forbidden_scope_violation", result: "pass", detail: "No forbidden path violations." };
+}
+/**
+ * Check 2: done_evidence_missing (warn level).
+ * Returns null when no done_evidence list is configured (skip).
+ * Returns pass when all listed files exist in the task directory.
+ * Returns warn when any listed file is missing.
+ */
+export function checkDoneEvidenceMissing(taskDir, doneEvidence) {
+    if (!doneEvidence || doneEvidence.length === 0)
+        return null;
+    const missing = [];
+    for (const filename of doneEvidence) {
+        if (!existsSync(join(taskDir, filename))) {
+            missing.push(filename);
+        }
+    }
+    if (missing.length > 0) {
+        return {
+            name: "done_evidence_missing",
+            result: "warn",
+            detail: `Missing: ${missing.join(", ")}`,
+        };
+    }
+    return { name: "done_evidence_missing", result: "pass", detail: "All done_evidence files present." };
+}
+const CODE_EXTENSIONS = new Set([
+    ".ts", ".js", ".jsx", ".tsx", ".py", ".go", ".java", ".rs",
+    ".c", ".cpp", ".cs", ".rb", ".php", ".swift", ".kt", ".scala",
+]);
+/**
+ * Check 3: readme_changelog_sync (warn level).
+ * Returns null when no code files (by extension) were changed (skip).
+ * Returns pass when README.md or CHANGELOG.md (basename, case-insensitive) is also changed.
+ * Returns warn when code changed but neither documentation file was updated.
+ */
+export function checkReadmeChangelogSync(changedFiles) {
+    const paths = changedFiles.map((f) => f.path);
+    const hasCodeChange = paths.some((p) => {
+        const lower = p.toLowerCase();
+        const dot = lower.lastIndexOf(".");
+        if (dot === -1)
+            return false;
+        return CODE_EXTENSIONS.has(lower.slice(dot));
+    });
+    if (!hasCodeChange)
+        return null;
+    const docsUpdated = paths.some((p) => {
+        const name = basename(p).toLowerCase();
+        return name === "readme.md" || name === "changelog.md";
+    });
+    if (docsUpdated) {
+        return {
+            name: "readme_changelog_sync",
+            result: "pass",
+            detail: "README.md or CHANGELOG.md updated with code changes.",
+        };
+    }
+    return {
+        name: "readme_changelog_sync",
+        result: "warn",
+        detail: "Code changes detected but README.md/CHANGELOG.md not updated.",
+    };
+}
+/**
+ * Check 4: package_manifest_consistency (warn level).
+ * Returns null when package.json is not among changed files (skip).
+ * Returns pass when package.json parses as JSON and has non-empty name and version strings.
+ * Returns warn otherwise.
+ */
+export function checkPackageManifestConsistency(changedFiles, repoPathSafe) {
+    const includesPackageJson = changedFiles.some((f) => basename(f.path).toLowerCase() === "package.json");
+    if (!includesPackageJson)
+        return null;
+    try {
+        const pkgPath = join(repoPathSafe, "package.json");
+        const raw = readFileSync(pkgPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const hasName = typeof parsed.name === "string" && parsed.name.length > 0;
+        const hasVersion = typeof parsed.version === "string" && parsed.version.length > 0;
+        if (hasName && hasVersion) {
+            return {
+                name: "package_manifest_consistency",
+                result: "pass",
+                detail: "package.json manifest fields are valid.",
+            };
+        }
+    }
+    catch {
+        // fall through to warn
+    }
+    return {
+        name: "package_manifest_consistency",
+        result: "warn",
+        detail: "package.json could not be parsed or missing name/version.",
+    };
+}
+/**
+ * Check 5: sensitive_path_access (fail level).
+ * Returns null when there are no changed files (skip).
+ * Returns pass when no changed file path (or old_path) is sensitive.
+ * Returns fail when any changed file path is flagged by isSensitivePath.
+ */
+export function checkSensitivePathAccess(changedFiles) {
+    if (changedFiles.length === 0)
+        return null;
+    const hits = [];
+    for (const file of changedFiles) {
+        const candidates = [file.path];
+        if (file.old_path)
+            candidates.push(file.old_path);
+        for (const candidate of candidates) {
+            if (isSensitivePath(candidate)) {
+                hits.push(candidate);
+            }
+        }
+    }
+    if (hits.length > 0) {
+        return {
+            name: "sensitive_path_access",
+            result: "fail",
+            detail: `Sensitive paths accessed: ${[...new Set(hits)].join(", ")}`,
+        };
+    }
+    return { name: "sensitive_path_access", result: "pass", detail: "No sensitive path access detected." };
+}
+const HIGH_RISK_COMMAND_PATTERNS = [
+    /\bnpm(?:\.cmd)?\s+publish\b/i,
+    /\bgit\s+push\b/i,
+    /\bcurl\s+https?:\/\//i,
+    /\bInvoke-WebRequest\b/i,
+    /\bRemove-Item\b[\s\S]{0,80}\b-Recurse\b/i,
+    /\brm\s+-rf\b/i,
+];
+function extractCommands(text) {
+    const found = [];
+    const runRe = /npm(?:\.cmd)?\s+run\s+([a-zA-Z0-9:_-]+)/gi;
+    let m;
+    while ((m = runRe.exec(text)) !== null)
+        found.push({ type: "npm-run", name: m[1] });
+    const bareRe = /npm(?:\.cmd)?\s+(?!run\b)([a-zA-Z]+)/gi;
+    while ((m = bareRe.exec(text)) !== null)
+        found.push({ type: "npm-bare", name: m[1] });
+    const nodeRe = /node\s+([a-zA-Z0-9_./\\-]+)/gi;
+    while ((m = nodeRe.exec(text)) !== null)
+        found.push({ type: "node", name: normalizeCommandName(m[1]) });
+    const npxRe = /npx\s+([a-zA-Z0-9_./\\@-]+)/gi;
+    while ((m = npxRe.exec(text)) !== null)
+        found.push({ type: "npx", name: normalizeCommandName(m[1]) });
+    const pythonRe = /python(?:3|\.exe)?\s+([a-zA-Z0-9_./\\-]+)/gi;
+    while ((m = pythonRe.exec(text)) !== null)
+        found.push({ type: "python", name: normalizeCommandName(m[1]) });
+    return found;
+}
+function normalizeCommandName(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function commandKey(command) {
+    return command.name;
+}
+function readPackageScripts(repoPath) {
+    if (!repoPath)
+        return {};
+    const pkgJsonPath = join(repoPath, "package.json");
+    if (!existsSync(pkgJsonPath))
+        return {};
+    try {
+        guardSensitivePath(pkgJsonPath);
+        const parsed = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+        if (!parsed.scripts || typeof parsed.scripts !== "object" || Array.isArray(parsed.scripts))
+            return {};
+        return Object.fromEntries(Object.entries(parsed.scripts).filter(([, value]) => typeof value === "string"));
+    }
+    catch {
+        return {};
+    }
+}
+function buildCommandWhitelist(verifyCommands, testCommand, repoPath) {
+    const scripts = readPackageScripts(repoPath);
+    const allowed = new Set();
+    const transitive = new Set();
+    const queue = [];
+    const sources = [...verifyCommands];
+    if (testCommand)
+        sources.push(testCommand);
+    for (const src of sources) {
+        for (const command of extractCommands(src)) {
+            allowed.add(commandKey(command));
+            queue.push({ command, depth: 0 });
+        }
+    }
+    let inspectedFiles = 0;
+    const seen = new Set();
+    while (queue.length > 0) {
+        const { command, depth } = queue.shift();
+        if (depth > 4)
+            continue;
+        const key = `${command.type}:${command.name}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const scriptName = command.type === "npm-run" || command.type === "npm-bare" ? command.name : null;
+        if (scriptName && scripts[scriptName]) {
+            for (const nested of extractCommands(scripts[scriptName])) {
+                transitive.add(commandKey(nested));
+                allowed.add(commandKey(nested));
+                queue.push({ command: nested, depth: depth + 1 });
+            }
+        }
+        if ((command.type === "node" || command.type === "python") && repoPath && inspectedFiles < 20) {
+            const nestedText = readLocalScript(repoPath, command.name);
+            if (nestedText) {
+                inspectedFiles++;
+                for (const nested of extractCommands(nestedText)) {
+                    transitive.add(commandKey(nested));
+                    allowed.add(commandKey(nested));
+                    queue.push({ command: nested, depth: depth + 1 });
+                }
+            }
+        }
+    }
+    return { allowed, transitive };
+}
+function readLocalScript(repoPath, scriptPath) {
+    const resolvedRepo = resolve(repoPath);
+    const resolvedScript = resolve(resolvedRepo, scriptPath);
+    const rel = relative(resolvedRepo, resolvedScript);
+    if (rel === ".." || rel.startsWith(`..${sep}`) || rel === "" || isAbsolute(rel))
+        return null;
+    if (!existsSync(resolvedScript))
+        return null;
+    try {
+        const stat = statSync(resolvedScript);
+        if (!stat.isFile() || stat.size > 200000)
+            return null;
+        return readFileSync(resolvedScript, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function findHighRiskCommandEvidence(text) {
+    const found = [];
+    for (const pattern of HIGH_RISK_COMMAND_PATTERNS) {
+        const match = text.match(pattern);
+        if (match)
+            found.push(match[0]);
+    }
+    return [...new Set(found)];
+}
+export function checkUnrecordedCommandExecution(testLogContent, resultMdContent, verifyCommands, testCommand, repoPath = null) {
+    const hasLog = testLogContent && testLogContent.length > 0;
+    const hasResult = resultMdContent && resultMdContent.length > 0;
+    if (!hasLog && !hasResult)
+        return null;
+    const combined = `${testLogContent || ""}\n${resultMdContent || ""}`;
+    const highRisk = findHighRiskCommandEvidence(combined);
+    if (highRisk.length > 0) {
+        return { name: "unrecorded_command_execution", result: "fail", detail: `High-risk command evidence: ${highRisk.join(", ")}` };
+    }
+    const whitelist = buildCommandWhitelist(verifyCommands, testCommand, repoPath);
+    const discovered = [];
+    if (hasLog)
+        discovered.push(...extractCommands(testLogContent));
+    if (hasResult)
+        discovered.push(...extractCommands(resultMdContent));
+    const unrecorded = new Set();
+    for (const cmd of discovered) {
+        if (!whitelist.allowed.has(commandKey(cmd)))
+            unrecorded.add(commandKey(cmd));
+    }
+    if (unrecorded.size > 0) {
+        return { name: "unrecorded_command_execution", result: "warn", detail: `Unrecorded commands: ${[...unrecorded].join(", ")}` };
+    }
+    const transitive = [...whitelist.transitive].filter((command) => discovered.some((entry) => commandKey(entry) === command));
+    return {
+        name: "unrecorded_command_execution",
+        result: "pass",
+        detail: transitive.length > 0 ? `All commands are whitelisted; transitive_verified_command: ${transitive.join(", ")}` : "All commands in whitelist.",
+    };
+}
 export function auditTask(taskId) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);
@@ -69,12 +427,13 @@ export function auditTask(taskId) {
     // ── 1. Task status ──
     const taskStatus = statusData.status || "unknown";
     const failedStatuses = new Set(["failed", "failed_verification", "failed_scope_violation", "failed_policy_violation", "canceled"]);
+    const doneStatuses = new Set(["done", "done_by_agent"]);
     checks.push({
         name: "task_status",
-        result: taskStatus === "done" ? "pass" : failedStatuses.has(taskStatus) ? "fail" : "warn",
+        result: doneStatuses.has(taskStatus) ? "pass" : failedStatuses.has(taskStatus) ? "fail" : "warn",
         detail: `Task status is "${taskStatus}".`,
     });
-    if (taskStatus !== "done" && !failedStatuses.has(taskStatus)) {
+    if (!doneStatuses.has(taskStatus) && !failedStatuses.has(taskStatus)) {
         addManualVerification(`Task status is "${taskStatus}"; audit evidence may be incomplete until terminal state.`);
     }
     // ── 2. result.md ──
@@ -129,10 +488,15 @@ export function auditTask(taskId) {
             ? `${newOutOfScope.length} new out-of-scope change(s) detected during task execution.`
             : "No new out-of-scope changes recorded.",
     });
+    // Extract changed_files from change evidence (used by several v0.7.2 checks).
+    let changedFiles = [];
     const changedFilesFile = join(taskDir, "changed-files.json");
     if (existsSync(changedFilesFile)) {
         try {
             const changeEvidence = JSON.parse(readFileSync(changedFilesFile, "utf-8"));
+            if (Array.isArray(changeEvidence.changed_files)) {
+                changedFiles = changeEvidence.changed_files;
+            }
             const hygiene = changeEvidence.artifact_hygiene;
             if (hygiene?.counts) {
                 const trackedArtifacts = Number(hygiene.counts.tracked_build_artifacts || 0);
@@ -314,10 +678,18 @@ export function auditTask(taskId) {
         addManualVerification("Verify remote npm, GitHub Release, and Git tag claims against authoritative remote services.");
     }
     // ── 9. test.log Exit code check ──
+    let testLogContent = null;
     if (hasTestLog) {
-        const testLogContent = readFileSync(testLogFile, "utf-8");
+        let logContent;
+        try {
+            logContent = readFileSync(testLogFile, "utf-8");
+        }
+        catch {
+            logContent = "";
+        }
+        testLogContent = logContent;
         // Check test_command visibility
-        if (statusData.test_command && testLogContent.includes(statusData.test_command)) {
+        if (statusData.test_command && logContent.includes(statusData.test_command)) {
             checks.push({ name: "test_command_in_log", result: "pass", detail: "test.log contains the configured test command." });
         }
         else if (statusData.test_command) {
@@ -325,7 +697,7 @@ export function auditTask(taskId) {
             addManualVerification("Confirm that test.log belongs to the configured test command.");
         }
         // Extract Exit code
-        const exitMatch = testLogContent.match(/Exit\s*code:\s*(\d+)/i);
+        const exitMatch = logContent.match(/Exit\s*code:\s*(\d+)/i);
         if (exitMatch) {
             const exitCode = parseInt(exitMatch[1]);
             if (exitCode === 0) {
@@ -343,6 +715,33 @@ export function auditTask(taskId) {
             addManualVerification("The configured test command has no recorded exit code; rerun or inspect verification evidence.");
         }
     }
+    // ── v0.7.2: New audit checks ──
+    // Read result.md content (guarded) for the unrecorded_command_execution check.
+    let resultMdContent = null;
+    if (hasResult) {
+        try {
+            resultMdContent = readFileSync(resultFile, "utf-8");
+        }
+        catch {
+            resultMdContent = null;
+        }
+    }
+    const verifyCommands = Array.isArray(statusData.verify_commands) ? statusData.verify_commands : [];
+    const testCommand = typeof statusData.test_command === "string" ? statusData.test_command : null;
+    const forbidden = Array.isArray(statusData.forbidden) ? statusData.forbidden : null;
+    const doneEvidence = Array.isArray(statusData.done_evidence) ? statusData.done_evidence : null;
+    const newChecks = [
+        checkForbiddenScope(changedFiles, forbidden),
+        checkDoneEvidenceMissing(taskDir, doneEvidence),
+        checkReadmeChangelogSync(changedFiles),
+        checkPackageManifestConsistency(changedFiles, repoPathSafe),
+        checkSensitivePathAccess(changedFiles),
+        checkUnrecordedCommandExecution(testLogContent, resultMdContent, verifyCommands, testCommand, repoPathSafe),
+    ];
+    for (const check of newChecks) {
+        if (check)
+            checks.push(check);
+    }
     // ── 10. Summarize ──
     const failCount = checks.filter((c) => c.result === "fail").length;
     const warnCount = checks.filter((c) => c.result === "warn").length;
@@ -390,9 +789,63 @@ export function auditTask(taskId) {
         ...actions.map((a) => `- ${a}`),
     ].join("\n");
     writeFileSync(join(taskDir, "independent-review.md"), reviewMd, "utf-8");
+    // ── v0.7.2: 集成 acceptanceEngine ──
+    const releaseClaimsUnverified = allReleaseClaims.length > 0;
+    const acceptanceEvidence = {
+        task_id: taskId,
+        task_status: taskStatus,
+        result_md_exists: hasResult,
+        result_json_exists: existsSync(resultJsonFile),
+        verify_json_exists: existsSync(verifyJsonFile),
+        test_log_exists: hasTestLog,
+        git_diff_exists: existsSync(join(taskDir, "git.diff")),
+        verify_status: (() => {
+            if (!existsSync(verifyJsonFile))
+                return null;
+            try {
+                const v = JSON.parse(readFileSync(verifyJsonFile, "utf-8"));
+                return v.status === "passed" ? "passed" : v.status === "failed" ? "failed" : "skipped";
+            }
+            catch {
+                return null;
+            }
+        })(),
+        new_out_of_scope_changes: newOutOfScope,
+        goal: statusData.goal ?? null,
+        scope: Array.isArray(statusData.scope) ? statusData.scope : null,
+        forbidden: Array.isArray(statusData.forbidden) ? statusData.forbidden : null,
+        verification: Array.isArray(statusData.verification) ? statusData.verification : null,
+        done_evidence: Array.isArray(statusData.done_evidence) ? statusData.done_evidence : null,
+        artifact_status: statusData.artifact_status ?? null,
+        release_claims_unverified: releaseClaimsUnverified,
+        checks: checks.map((c) => ({ name: c.name, result: c.result, detail: c.detail })),
+    };
+    const acceptanceResult = evaluateAcceptance(acceptanceEvidence);
+    // 回写 status.json 的 acceptance_status（仅对 done_by_agent 有意义）
+    if (taskStatus === "done_by_agent") {
+        const updatedStatus = {
+            ...statusData,
+            acceptance_status: acceptanceResult.acceptance_status,
+            updated_at: new Date().toISOString(),
+        };
+        writeFileSync(statusFile, JSON.stringify(updatedStatus, null, 2), "utf-8");
+    }
+    // 导出 ACCEPTANCE.md
+    const acceptanceMd = renderAcceptanceMarkdown(taskId, acceptanceResult, acceptanceEvidence);
+    writeFileSync(join(taskDir, "ACCEPTANCE.md"), acceptanceMd, "utf-8");
     return {
         task_id: taskId,
         verdict,
+        acceptance: {
+            verdict: acceptanceResult.verdict,
+            status: acceptanceResult.acceptance_status ?? "null",
+            reason: acceptanceResult.reason,
+            reasons: acceptanceResult.reasons,
+            required_evidence: acceptanceResult.required_evidence,
+            next_suggested_task: acceptanceResult.next_suggested_task,
+            fail_checks: acceptanceResult.fail_checks,
+            warn_checks: acceptanceResult.warn_checks,
+        },
         summary,
         checks,
         risks,

package/dist/tools/cancelTask.js

@@ -15,7 +15,7 @@ export function requestTaskTermination(taskId, force) {
         throw new Error(`Task not found: "${taskId}"`);
     const data = JSON.parse(readFileSync(statusFile, "utf-8"));
     const currentStatus = data.status;
-    if (["done", "failed", "failed_verification", "failed_scope_violation", "failed_policy_violation", "canceled"].includes(currentStatus)) {
+    if (["done", "done_by_agent", "failed", "failed_verification", "failed_scope_violation", "failed_policy_violation", "canceled"].includes(currentStatus)) {
         return {
             task_id: taskId,
             previous_status: currentStatus,

package/dist/tools/checkReleaseGate.d.ts

@@ -0,0 +1,21 @@
+import { type ReleaseStage } from "../release/releaseGate.js";
+export interface CheckReleaseGateInput {
+    repo_path: string;
+    target_stage: ReleaseStage;
+    package_name?: string;
+    version?: string;
+    github_repo?: string;
+    branch?: string;
+}
+/**
+ * MCP tool handler for the release gate.
+ *
+ * Validates repo_path against the workspace boundary, runs the release-gate
+ * stages up to target_stage, and returns the result as a JSON text blob.
+ */
+export declare function checkReleaseGate(input: CheckReleaseGateInput): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;

package/dist/tools/checkReleaseGate.js

@@ -0,0 +1,22 @@
+import { getConfig } from "../config.js";
+import { guardWorkspacePath } from "../security/pathGuard.js";
+import { runReleaseGateCheck, } from "../release/releaseGate.js";
+/**
+ * MCP tool handler for the release gate.
+ *
+ * Validates repo_path against the workspace boundary, runs the release-gate
+ * stages up to target_stage, and returns the result as a JSON text blob.
+ */
+export async function checkReleaseGate(input) {
+    const config = getConfig();
+    const repoPath = guardWorkspacePath(input.repo_path, config.workspaceRoot);
+    const result = await runReleaseGateCheck(repoPath, input.target_stage, {
+        packageName: input.package_name,
+        version: input.version,
+        githubRepo: input.github_repo,
+        branch: input.branch,
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+}

package/dist/tools/createTask.d.ts

@@ -1,7 +1,17 @@
 import { type ChangePolicy, type TaskTemplateName } from "./taskTemplates.js";
 import { type PendingReason, type WatcherStatusSnapshot } from "../watcherStatus.js";
-export type TaskStatus = "pending" | "running" | "done" | "failed" | "failed_verification" | "failed_scope_violation" | "failed_policy_violation" | "canceled";
-export type TaskPhase = "queued" | "preparing" | "executing_agent" | "running_tests" | "collecting_artifacts" | "canceling" | "terminating" | "completed" | "failed" | "failed_verification" | "failed_scope_violation" | "failed_policy_violation" | "canceled";
+export type TaskStatus = "pending" | "running" | "collecting_artifacts" | "done_by_agent" | "accepted" | "rejected" | "needs_fix" | "blocked" | "done" | "failed" | "failed_verification" | "failed_scope_violation" | "failed_policy_violation" | "failed_stale" | "orphaned" | "canceled";
+/**
+ * v0.7.2 acceptance status — only meaningful for done_by_agent.
+ * - "pending": done_by_agent reached but not yet audited/accepted
+ * - "accepted": audit_task confirmed all evidence passes
+ * - "rejected": audit_task found fail-level issues
+ * - "needs_fix": audit_task found warn-level issues requiring fixes
+ * - "blocked": audit_task blocked by approval boundary (e.g. release claims)
+ * - null: status has no acceptance semantics (running, failed, etc.)
+ */
+export type AcceptanceStatus = "pending" | "accepted" | "rejected" | "needs_fix" | "blocked" | null;
+export type TaskPhase = "queued" | "preparing" | "executing_agent" | "running_tests" | "collecting_artifacts" | "canceling" | "terminating" | "completed" | "failed" | "failed_verification" | "failed_scope_violation" | "failed_policy_violation" | "failed_stale" | "orphaned" | "done_by_agent" | "accepted" | "rejected" | "needs_fix" | "blocked" | "canceled";
 export interface CreateTaskInput {
     plan_id?: string;
     inline_plan?: string;
@@ -16,6 +26,12 @@ export interface CreateTaskInput {
     timeout_seconds?: number;
     execution_mode?: "assess_only" | "execute";
     assessment_id?: string;
+    scope?: string[];
+    forbidden?: string[];
+    verification?: string[];
+    done_evidence?: string[];
+    goal_id?: string;
+    subgoal_id?: string;
 }
 export interface AssessOnlyOutput {
     assessment_id: string;

package/dist/tools/createTask.js

@@ -17,6 +17,7 @@ import { expandTaskTemplate, TASK_TEMPLATE_NAMES, } from "./taskTemplates.js";
 import { PATCHWARDEN_VERSION } from "../version.js";
 import { getLastToolCatalogSnapshot, resolveToolProfile } from "./toolCatalog.js";
 import { derivePendingReason, readWatcherStatus, } from "../watcherStatus.js";
+import { routeAgent } from "../agents/agentRouter.js";
 export function createTask(input) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);
@@ -33,8 +34,23 @@ export function createTask(input) {
     // ── Validate required fields ──
     // agent and repo_path are required unless assessment_id fills them.
     // assess_only always requires them because the risk engine needs to check them.
+    // v1.0.0: agent is now optional — if omitted, routeAgent recommends one based on scope/goal/plan.
+    let agentSelectionReason;
     if (!effectiveInput.agent || effectiveInput.agent.trim() === "") {
-        throw new PatchWardenError("agent_required", "create_task requires an agent name.", "Pass a configured agent name, or use assessment_id from a prior assess_only call.");
+        const configuredAgents = Object.keys(config.agents);
+        const routeResult = routeAgent({
+            goal: effectiveInput.goal,
+            scope: effectiveInput.scope,
+            inline_plan: effectiveInput.inline_plan,
+            template: effectiveInput.template,
+            configuredAgents,
+        });
+        effectiveInput.agent = routeResult.recommended_agent;
+        agentSelectionReason = {
+            recommended_agent: routeResult.recommended_agent,
+            reason: routeResult.reason,
+            fallback: routeResult.fallback,
+        };
     }
     const planSources = [
         effectiveInput.plan_id?.trim() ? "plan_id" : "",
@@ -344,6 +360,18 @@ export function createTask(input) {
         last_heartbeat_at: new Date().toISOString(),
         current_command: null,
         error: null,
+        // v0.7.2: 验收标准绑定到任务创建
+        goal: effectiveInput.goal || null,
+        scope: effectiveInput.scope ?? null,
+        forbidden: effectiveInput.forbidden ?? null,
+        verification: effectiveInput.verification ?? null,
+        done_evidence: effectiveInput.done_evidence ?? null,
+        acceptance_status: null,
+        // v0.8.0: Goal Session 关联
+        goal_id: effectiveInput.goal_id ?? null,
+        subgoal_id: effectiveInput.subgoal_id ?? null,
+        // v1.0.0: Agent routing decision (only present when agent was auto-routed)
+        ...(agentSelectionReason ? { agent_selection_reason: agentSelectionReason } : {}),
     };
     writeFileSync(statusFile, JSON.stringify(statusData, null, 2), "utf-8");
     writeTaskProgress(taskDir, "queued", {