patchwarden 0.6.1 → 1.1.0

package/dist/tools/safeStatus.js

@@ -5,6 +5,7 @@ import { guardReadPath } from "../security/pathGuard.js";
 import { guardSensitivePath } from "../security/sensitiveGuard.js";
 import { readTaskRuntime } from "../taskRuntime.js";
 import { readWatcherStatus } from "../watcherStatus.js";
+import { diagnoseTask } from "./diagnoseTask.js";
 export function safeStatus(taskId, config) {
     const cfg = config || getConfig();
     const tasksDir = getTasksDir(cfg);
@@ -16,6 +17,8 @@ export function safeStatus(taskId, config) {
         return {
             task_id: taskId,
             status: "not_found",
+            legacy_status: null,
+            acceptance_status: null,
             phase: null,
             created_at: null,
             started_at: null,
@@ -28,6 +31,8 @@ export function safeStatus(taskId, config) {
             watcher_state: null,
             error_code: null,
             error_summary: null,
+            stale_seconds: null,
+            diagnosis: null,
         };
     }
     guardReadPath(statusFile, cfg.workspaceRoot, cfg.tasksDir);
@@ -53,9 +58,44 @@ export function safeStatus(taskId, config) {
         errorCode = status.status;
         errorSummary = `Task ended with status: ${status.status}`;
     }
+    // v0.7.2: derive legacy_status and acceptance_status
+    const statusStr = status.status || "not_found";
+    const legacyStatus = (statusStr === "done_by_agent" || statusStr === "accepted") ? "done" : null;
+    const VALID_ACCEPTANCE = ["pending", "accepted", "rejected", "needs_fix", "blocked"];
+    const acceptanceStatus = statusStr === "done_by_agent"
+        ? (typeof status.acceptance_status === "string" && VALID_ACCEPTANCE.includes(status.acceptance_status)
+            ? status.acceptance_status
+            : "pending") // default for done_by_agent when field missing
+        : null;
+    // v0.7.0: compute stale_seconds from the most recent heartbeat
+    const heartbeatStr = (typeof runtime.last_heartbeat_at === "string" && runtime.last_heartbeat_at) ||
+        (typeof status.last_heartbeat_at === "string" && status.last_heartbeat_at) ||
+        (typeof status.updated_at === "string" && status.updated_at) ||
+        null;
+    let staleSeconds = null;
+    if (heartbeatStr) {
+        const heartbeatMs = Date.parse(heartbeatStr);
+        if (Number.isFinite(heartbeatMs)) {
+            staleSeconds = Math.max(0, Math.round((Date.now() - heartbeatMs) / 1000));
+        }
+    }
+    // v0.7.0: lightweight diagnosis snapshot — only for non-terminal tasks.
+    // Wrap in try/catch so a diagnosis failure never breaks safe_status.
+    let diagnosis = null;
+    if (statusStr === "running" || statusStr === "collecting_artifacts" || statusStr === "pending") {
+        try {
+            const result = diagnoseTask({ task_id: taskId }, cfg);
+            diagnosis = { type: result.diagnosis, confidence: result.confidence };
+        }
+        catch {
+            diagnosis = null;
+        }
+    }
     return {
         task_id: taskId,
-        status: status.status || "not_found",
+        status: statusStr,
+        legacy_status: legacyStatus,
+        acceptance_status: acceptanceStatus,
         phase,
         created_at: typeof status.created_at === "string" ? status.created_at : null,
         started_at: typeof status.started_at === "string" ? status.started_at : null,
@@ -68,5 +108,7 @@ export function safeStatus(taskId, config) {
         watcher_state: watcher.status,
         error_code: errorCode,
         error_summary: errorSummary,
+        stale_seconds: staleSeconds,
+        diagnosis,
     };
 }

package/dist/tools/safeViews.d.ts

@@ -0,0 +1,256 @@
+export interface SafeViewOptions {
+    max_items?: number;
+}
+export declare function safeResult(taskId: string, options?: SafeViewOptions): {
+    task_id: string;
+    status: string;
+    terminal: boolean;
+    acceptance_status: "failed" | "pending" | "ready_for_review" | "needs_review";
+    phase: string;
+    repo_path: string;
+    changed_files_total: number;
+    out_of_scope_changes_total: number;
+    artifact_hygiene_counts: Record<string, number>;
+    release_artifacts_count: number;
+    artifact_status: string | null;
+    verification: {
+        status: string;
+        command_count: number;
+        passed_commands: number;
+        failed_commands: number;
+        skipped_commands: number;
+        headline: string;
+    };
+    warnings: string[];
+    errors: string[];
+    failure_reason: string | null;
+    failed_command: string | null;
+    next_action: string;
+    execution_blocked: boolean;
+    pending_reason: string | null;
+    redacted: boolean;
+    redaction_categories: string[];
+};
+export declare function safeTestSummary(taskId: string): {
+    task_id: string;
+    status: string;
+    command_count: number;
+    passed_commands: number;
+    failed_commands: number;
+    skipped_commands: number;
+    commands: {
+        command: string;
+        status: string;
+        exit_code: any;
+        duration_ms: number;
+    }[];
+    headline: string;
+};
+export declare function safeDiffSummary(taskId: string, options?: SafeViewOptions): {
+    task_id: string;
+    changed_files_total: number;
+    additions: number;
+    deletions: number;
+    diff_available: boolean;
+    diff_truncated: boolean;
+    patch_mode: any;
+    files: {
+        path: string;
+        old_path: string | null;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+    }[];
+    artifact_hygiene_counts: Record<string, any>;
+    large_diff_omitted: boolean;
+    truncated: boolean;
+};
+export declare function safeAudit(taskId: string, options?: SafeViewOptions): {
+    task_id: string;
+    verdict: "pass" | "warn" | "fail";
+    acceptance: {
+        verdict: string;
+        status: string;
+        reason: string;
+        fail_checks: string[];
+        warn_checks: string[];
+        next_suggested_task: string;
+    };
+    check_counts: {
+        pass: number;
+        warn: number;
+        fail: number;
+    };
+    checks: {
+        name: string;
+        result: "pass" | "warn" | "fail";
+        detail: string;
+    }[];
+    fail_checks: {
+        name: string;
+        result: "pass" | "warn" | "fail";
+        detail: string;
+    }[];
+    warn_checks: {
+        name: string;
+        result: "pass" | "warn" | "fail";
+        detail: string;
+    }[];
+    possible_false_positives: {
+        check: string;
+        reason: string;
+    }[];
+    manual_verification_required: boolean;
+    manual_verification_items: string[];
+    recommended_next_actions: string[];
+};
+export declare function safeDirectSummary(sessionId: string, options?: SafeViewOptions): {
+    view: "summary" | "finalize";
+    session_id: string;
+    title: string;
+    repo_path: string;
+    created_at: string;
+    expires_at: string;
+    finalized: boolean;
+    finalized_at: string | null;
+    audited: boolean;
+    changed_files_total: number;
+    files: {
+        path: string;
+        old_path: string | null;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+    }[];
+    artifact_hygiene_counts: {};
+    source_changes: {
+        path: string;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+        reason: string;
+    }[];
+    tracked_build_artifacts: {
+        path: string;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+        reason: string;
+    }[];
+    runtime_generated_files: {
+        path: string;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+        reason: string;
+    }[];
+    suspicious_changes: {
+        path: string;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+        reason: string;
+    }[];
+    verification: {
+        command: string;
+        exit_code: number | null;
+        passed: boolean;
+        timed_out: boolean;
+        started_at: string;
+        finished_at: string;
+    }[];
+    large_diff_omitted: boolean;
+    truncated: boolean;
+};
+export declare function safeFinalizeDirectSession(sessionId: string, options?: SafeViewOptions): {
+    finalized: boolean;
+    next_action: string;
+    view: "summary" | "finalize";
+    session_id: string;
+    title: string;
+    repo_path: string;
+    created_at: string;
+    expires_at: string;
+    finalized_at: string | null;
+    audited: boolean;
+    changed_files_total: number;
+    files: {
+        path: string;
+        old_path: string | null;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+    }[];
+    artifact_hygiene_counts: {};
+    source_changes: {
+        path: string;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+        reason: string;
+    }[];
+    tracked_build_artifacts: {
+        path: string;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+        reason: string;
+    }[];
+    runtime_generated_files: {
+        path: string;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+        reason: string;
+    }[];
+    suspicious_changes: {
+        path: string;
+        change: "added" | "modified" | "deleted" | "renamed";
+        kind: "source" | "build_artifact" | "runtime_generated";
+        tracked: boolean;
+        ignored: boolean;
+        reason: string;
+    }[];
+    verification: {
+        command: string;
+        exit_code: number | null;
+        passed: boolean;
+        timed_out: boolean;
+        started_at: string;
+        finished_at: string;
+    }[];
+    large_diff_omitted: boolean;
+    truncated: boolean;
+};
+export declare function safeAuditDirectSession(sessionId: string, options?: SafeViewOptions): {
+    session_id: string;
+    decision: "pass" | "warn" | "fail";
+    reason_codes: string[];
+    blocking_findings: string[];
+    warnings: string[];
+    evidence: {
+        changed_files_total: number;
+        verification_runs: {
+            command: string;
+            exit_code: number | null;
+            passed: boolean;
+            timed_out: boolean;
+            started_at: string;
+            finished_at: string;
+        }[];
+        diff_available: boolean;
+        summary_available: boolean;
+        audit_available: boolean;
+    };
+    next_action: string;
+};

package/dist/tools/safeViews.js

@@ -0,0 +1,250 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { getConfig, getTasksDir } from "../config.js";
+import { auditSession } from "./auditSession.js";
+import { auditTask } from "./auditTask.js";
+import { finalizeDirectSession } from "./finalizeDirectSession.js";
+import { getTaskSummary } from "./getTaskSummary.js";
+import { guardReadPath } from "../security/pathGuard.js";
+import { redactSensitiveValue } from "../security/contentRedaction.js";
+import { readDirectSession } from "../direct/directSessionStore.js";
+export function safeResult(taskId, options = {}) {
+    const maxItems = normalizeMaxItems(options.max_items);
+    const summary = getTaskSummary(taskId, { view: "compact", max_items: maxItems });
+    return redact({
+        task_id: summary.task_id,
+        status: summary.status,
+        terminal: summary.terminal,
+        acceptance_status: summary.acceptance_status,
+        phase: summary.phase,
+        repo_path: summary.repo_path,
+        changed_files_total: summary.changed_files_total,
+        out_of_scope_changes_total: summary.out_of_scope_changes_total,
+        artifact_hygiene_counts: summary.artifact_hygiene.counts,
+        release_artifacts_count: summary.release_artifacts_count,
+        artifact_status: summary.artifact_status,
+        verification: summary.verification_summary,
+        warnings: limitStrings(summary.warnings, maxItems),
+        errors: limitStrings(summary.errors, maxItems),
+        failure_reason: summary.failure_reason,
+        failed_command: summary.failed_command,
+        next_action: summary.suggested_next_action,
+        execution_blocked: summary.execution_blocked,
+        pending_reason: summary.pending_reason,
+        redacted: summary.redacted,
+        redaction_categories: summary.redaction_categories,
+    });
+}
+export function safeTestSummary(taskId) {
+    const { taskDir, config } = getTaskDir(taskId);
+    const verify = readJson(join(taskDir, "verify.json"), config);
+    const summary = getTaskSummary(taskId, { view: "compact", max_items: 8 });
+    const commands = asArray(verify.commands).map((entry) => ({
+        command: String(entry.command || ""),
+        status: String(entry.status || "unknown"),
+        exit_code: entry.exit_code ?? null,
+        duration_ms: Number(entry.duration_ms || 0),
+    }));
+    return redact({
+        task_id: taskId,
+        status: String(verify.status || summary.verification_summary.status || "not_available"),
+        command_count: commands.length,
+        passed_commands: commands.filter((entry) => entry.status === "passed").length,
+        failed_commands: commands.filter((entry) => ["failed", "timed_out", "canceled"].includes(entry.status)).length,
+        skipped_commands: commands.filter((entry) => entry.status === "skipped").length,
+        commands,
+        headline: summary.verification_summary.headline,
+    });
+}
+export function safeDiffSummary(taskId, options = {}) {
+    const maxItems = normalizeMaxItems(options.max_items);
+    const { taskDir, config } = getTaskDir(taskId);
+    const changes = readJson(join(taskDir, "changed-files.json"), config);
+    const changedFiles = asArray(changes.changed_files);
+    const hygiene = asRecord(changes.artifact_hygiene);
+    return redact({
+        task_id: taskId,
+        changed_files_total: changedFiles.length,
+        additions: Number(changes.additions || 0),
+        deletions: Number(changes.deletions || 0),
+        diff_available: Boolean(changes.diff_available),
+        diff_truncated: Boolean(changes.diff_truncated),
+        patch_mode: changes.patch_mode || null,
+        files: changedFiles.slice(0, maxItems).map((file) => ({
+            path: file.path,
+            old_path: file.old_path || null,
+            change: file.change,
+            kind: file.kind,
+            tracked: Boolean(file.tracked),
+            ignored: Boolean(file.ignored),
+        })),
+        artifact_hygiene_counts: asRecord(hygiene.counts),
+        large_diff_omitted: true,
+        truncated: changedFiles.length > maxItems,
+    });
+}
+export function safeAudit(taskId, options = {}) {
+    const maxItems = normalizeMaxItems(options.max_items);
+    return auditToSafe(auditTask(taskId), maxItems);
+}
+export function safeDirectSummary(sessionId, options = {}) {
+    const maxItems = normalizeMaxItems(options.max_items);
+    const session = readDirectSession(sessionId);
+    return directSessionToSafe(session, maxItems, "summary");
+}
+export function safeFinalizeDirectSession(sessionId, options = {}) {
+    const maxItems = normalizeMaxItems(options.max_items);
+    const finalized = finalizeDirectSession({ session_id: sessionId });
+    const session = readDirectSession(sessionId);
+    return redact({
+        ...directSessionToSafe(session, maxItems, "finalize"),
+        finalized: finalized.finalized,
+        next_action: finalized.next_action,
+    });
+}
+export function safeAuditDirectSession(sessionId, options = {}) {
+    const maxItems = normalizeMaxItems(options.max_items);
+    const audit = auditSession({ session_id: sessionId });
+    return redact({
+        session_id: audit.session_id,
+        decision: audit.decision,
+        reason_codes: audit.reason_codes.slice(0, maxItems),
+        blocking_findings: limitStrings(audit.blocking_findings, maxItems),
+        warnings: limitStrings(audit.warnings, maxItems),
+        evidence: {
+            changed_files_total: audit.evidence.changed_files_total,
+            verification_runs: summarizeVerificationRuns(audit.evidence.verification_runs),
+            diff_available: Boolean(audit.evidence.diff_path),
+            summary_available: Boolean(audit.evidence.summary_path),
+            audit_available: Boolean(audit.evidence.audit_path),
+        },
+        next_action: audit.next_action,
+    });
+}
+function auditToSafe(audit, maxItems) {
+    const checks = audit.checks.map((check) => ({
+        name: check.name,
+        result: check.result,
+        detail: truncate(check.detail, 240),
+    }));
+    return redact({
+        task_id: audit.task_id,
+        verdict: audit.verdict,
+        acceptance: {
+            verdict: audit.acceptance.verdict,
+            status: audit.acceptance.status,
+            reason: truncate(audit.acceptance.reason, 240),
+            fail_checks: audit.acceptance.fail_checks.slice(0, maxItems).map((check) => check.name),
+            warn_checks: audit.acceptance.warn_checks.slice(0, maxItems).map((check) => check.name),
+            next_suggested_task: truncate(audit.acceptance.next_suggested_task, 240),
+        },
+        check_counts: {
+            pass: checks.filter((check) => check.result === "pass").length,
+            warn: checks.filter((check) => check.result === "warn").length,
+            fail: checks.filter((check) => check.result === "fail").length,
+        },
+        checks: checks.slice(0, maxItems),
+        fail_checks: checks.filter((check) => check.result === "fail").slice(0, maxItems),
+        warn_checks: checks.filter((check) => check.result === "warn").slice(0, maxItems),
+        possible_false_positives: audit.possible_false_positives.slice(0, maxItems).map((item) => ({
+            check: item.check,
+            reason: truncate(item.reason, 240),
+        })),
+        manual_verification_required: audit.manual_verification_required,
+        manual_verification_items: limitStrings(audit.manual_verification_items, maxItems),
+        recommended_next_actions: limitStrings(audit.recommended_next_actions, maxItems),
+    });
+}
+function directSessionToSafe(session, maxItems, view) {
+    const artifacts = session.change_artifacts;
+    const changedFiles = artifacts?.changed_files || [];
+    return redact({
+        view,
+        session_id: session.session_id,
+        title: session.title || "",
+        repo_path: session.repo_path,
+        created_at: session.created_at,
+        expires_at: session.expires_at,
+        finalized: session.finalized,
+        finalized_at: session.finalized_at,
+        audited: session.audited,
+        changed_files_total: changedFiles.length,
+        files: changedFiles.slice(0, maxItems).map((file) => ({
+            path: file.path,
+            old_path: file.old_path || null,
+            change: file.change,
+            kind: file.kind,
+            tracked: Boolean(file.tracked),
+            ignored: Boolean(file.ignored),
+        })),
+        artifact_hygiene_counts: artifacts?.artifact_hygiene.counts || {},
+        source_changes: limitClassified(artifacts?.artifact_hygiene.source_changes, maxItems),
+        tracked_build_artifacts: limitClassified(artifacts?.artifact_hygiene.tracked_build_artifacts, maxItems),
+        runtime_generated_files: limitClassified(artifacts?.artifact_hygiene.runtime_generated_files, maxItems),
+        suspicious_changes: limitClassified(artifacts?.artifact_hygiene.suspicious_changes, maxItems),
+        verification: summarizeVerificationRuns(session.verification_runs),
+        large_diff_omitted: true,
+        truncated: changedFiles.length > maxItems,
+    });
+}
+function summarizeVerificationRuns(runs) {
+    return runs.map((run) => ({
+        command: run.command,
+        exit_code: run.exit_code,
+        passed: run.passed,
+        timed_out: run.timed_out,
+        started_at: run.started_at,
+        finished_at: run.finished_at,
+    }));
+}
+function limitClassified(value, maxItems) {
+    return (value || []).slice(0, maxItems).map((entry) => ({
+        path: entry.path,
+        change: entry.change,
+        kind: entry.kind,
+        tracked: entry.tracked,
+        ignored: entry.ignored,
+        reason: truncate(entry.reason, 160),
+    }));
+}
+function getTaskDir(taskId) {
+    const config = getConfig();
+    const taskDir = resolve(getTasksDir(config), taskId);
+    guardReadPath(join(taskDir, "status.json"), config.workspaceRoot, config.tasksDir);
+    return { config, taskDir };
+}
+function readJson(path, config) {
+    guardReadPath(path, config.workspaceRoot, config.tasksDir);
+    if (!existsSync(path))
+        return {};
+    try {
+        const raw = readFileSync(path, "utf-8").replace(/^\uFEFF/, "");
+        return asRecord(JSON.parse(raw));
+    }
+    catch {
+        return {};
+    }
+}
+function normalizeMaxItems(value) {
+    if (value === undefined)
+        return 8;
+    if (!Number.isInteger(value) || value < 1 || value > 50) {
+        throw new Error("max_items must be an integer from 1 to 50.");
+    }
+    return value;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function limitStrings(values, maxItems) {
+    return values.slice(0, maxItems).map((value) => truncate(value, 240));
+}
+function truncate(value, maxChars) {
+    return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...`;
+}
+function redact(value) {
+    return redactSensitiveValue(value).value;
+}

package/dist/tools/schemaDriftCheck.d.ts

@@ -0,0 +1,46 @@
+/**
+ * v0.9.0: Schema 漂移检测模块。
+ *
+ * 检测 registry 元数据与实际工具 schema 是否漂移，
+ * 并聚合为可被 doctor 自检消费的 SchemaDriftResult。
+ *
+ * 本模块只做检测和报告，不做运行时阻断。
+ */
+import type { PatchWardenToolMeta } from "./toolRegistry.js";
+export interface SchemaDriftResult {
+    /** true 表示无 drift，false 表示有 drift */
+    ok: boolean;
+    /** drift 描述列表（每个 drift 一条警告消息） */
+    warnings: string[];
+}
+/** toolDefs Map 的值类型：至少包含 inputSchema。 */
+export interface ToolDefLike {
+    inputSchema: unknown;
+}
+/**
+ * 检查 registry 中记录的 inputSchemaDigest 与实际 toolDef 的 inputSchema digest 是否一致。
+ * toolDefs 中找不到的工具会被跳过（不报 drift）。
+ */
+export declare function checkRegistrySchemaDigest(registry: PatchWardenToolMeta[], toolDefs: Map<string, ToolDefLike>): SchemaDriftResult;
+/**
+ * 校验 chatgpt_core profile 的工具 manifest 是否稳定。
+ *
+ * toolCatalog.ts 未导出独立的 manifest hash 计算函数（stableJson 为私有），
+ * 因此采用 fallback 方案：校验 CHATGPT_CORE_TOOL_NAMES 中的工具名
+ * 全部存在于 toolDefs 中（集合比较，不比较顺序——Map 迭代顺序取决于构造
+ * 方式，不一定与 chatgpt_core profile 顺序一致）。
+ *
+ * 真正的顺序稳定性由 CHATGPT_CORE_TOOL_NAMES 常量本身保证（顺序固定），
+ * 如果常量被修改，这里的名称集合比较也会检测到变化。
+ */
+export declare function checkChatgptCoreManifestStable(toolDefs: Map<string, ToolDefLike>): SchemaDriftResult;
+/**
+ * 校验 chatgpt_core profile 的工具数仍与 CHATGPT_CORE_TOOL_NAMES 一致。
+ * 用于检测是否有新工具被意外追加到 chatgpt_core profile。
+ */
+export declare function checkNewToolsProfileAppend(registry: PatchWardenToolMeta[]): SchemaDriftResult;
+/**
+ * 聚合执行所有 schema drift 检查，合并 warnings。
+ * ok = warnings.length === 0
+ */
+export declare function runAllSchemaDriftChecks(registry: PatchWardenToolMeta[], toolDefs: Map<string, ToolDefLike>): SchemaDriftResult;