patchwarden 0.4.0

package/dist/tools/createTask.js

@@ -0,0 +1,188 @@
+import { mkdirSync, writeFileSync, existsSync, statSync } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getTasksDir, getPlansDir, getConfig } from "../config.js";
+import { guardPath, guardWorkspacePath, guardReadPath } from "../security/pathGuard.js";
+import { guardTestCommand } from "../security/commandGuard.js";
+import { writeTaskProgress } from "../taskProgress.js";
+import { PatchWardenError } from "../errors.js";
+import { savePlan } from "./savePlan.js";
+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";
+export function createTask(input) {
+    const config = getConfig();
+    const tasksDir = getTasksDir(config);
+    const plansDir = getPlansDir(config);
+    const planSources = [
+        input.plan_id?.trim() ? "plan_id" : "",
+        input.inline_plan?.trim() ? "inline_plan" : "",
+        input.template ? "template" : "",
+    ].filter(Boolean);
+    if (planSources.length !== 1) {
+        throw new PatchWardenError("invalid_plan_source", "create_task requires exactly one of plan_id, inline_plan, or template.", "Use an existing plan_id, pass inline_plan text, or choose one built-in template.");
+    }
+    if (input.template && !TASK_TEMPLATE_NAMES.includes(input.template)) {
+        throw new PatchWardenError("invalid_task_template", `Unknown task template "${input.template}".`, `Use one of: ${TASK_TEMPLATE_NAMES.join(", ")}.`);
+    }
+    // Resolve repo alias if configured
+    let resolvedRepoPath = input.repo_path?.trim() || "";
+    const aliases = config.repoAliases;
+    if (aliases && resolvedRepoPath && aliases[resolvedRepoPath]) {
+        resolvedRepoPath = aliases[resolvedRepoPath];
+    }
+    if (!resolvedRepoPath || resolvedRepoPath === "") {
+        throw new PatchWardenError("repo_path_required", "create_task requires an explicit repo_path; PatchWarden will not default to workspaceRoot.", 'Pass a repository path inside workspaceRoot, for example repo_path: "my-project".', true, { operation: "create_task", safe_alternative: "Pass an existing repository directory under workspaceRoot." });
+    }
+    // Validate agent
+    if (!config.agents[input.agent]) {
+        throw new PatchWardenError("agent_not_configured", `Unknown agent "${input.agent}". Available: ${Object.keys(config.agents).join(", ")}`, "Call list_agents and use an available configured agent.");
+    }
+    // Validate repo_path is within workspace
+    const safeRepoPath = guardWorkspacePath(resolvedRepoPath, config.workspaceRoot);
+    if (!existsSync(safeRepoPath)) {
+        throw new PatchWardenError("repo_path_not_found", `repo_path "${resolvedRepoPath}" resolves to "${safeRepoPath}", but that path does not exist.`, "Create the repository directory first or pass an existing path under workspaceRoot.", true, { operation: "create_task", path: resolvedRepoPath, resolved_repo_path: safeRepoPath, safe_alternative: "Use an existing repository directory under workspaceRoot." });
+    }
+    if (!statSync(safeRepoPath).isDirectory()) {
+        throw new PatchWardenError("repo_path_not_directory", `repo_path "${resolvedRepoPath}" resolves to a file, not a directory.`, "Pass the repository directory instead of a file path.", true, { operation: "create_task", path: resolvedRepoPath, resolved_repo_path: safeRepoPath, safe_alternative: "Pass the containing repository directory instead of a file." });
+    }
+    // Runtime self-modification protection: refuse to modify the active
+    // PatchWarden runtime directory or its critical subdirectories.
+    const runtimeRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+    const criticalDirs = ["dist", "src", "scripts", "release"];
+    if (safeRepoPath === runtimeRoot || safeRepoPath.startsWith(runtimeRoot + resolve("/")[0])) {
+        const isCritical = criticalDirs.some((dir) => safeRepoPath === join(runtimeRoot, dir) ||
+            safeRepoPath.startsWith(join(runtimeRoot, dir) + resolve("/")[0]));
+        if (safeRepoPath === runtimeRoot || isCritical) {
+            throw new PatchWardenError("runtime_self_modification_blocked", `repo_path "${resolvedRepoPath}" points to the active PatchWarden runtime or its critical subdirectories.`, "Use a dev copy or git worktree for PatchWarden development. The running MCP server must not be modified by a task.", true, {
+                operation: "create_task",
+                path: resolvedRepoPath,
+                resolved_repo_path: safeRepoPath,
+                runtime_root: runtimeRoot,
+                safe_alternative: "Clone or copy PatchWarden to a separate directory for development tasks.",
+            });
+        }
+    }
+    // Validate test command — must be in allowlist, no swallowing
+    let testCmd = "";
+    if (input.test_command && input.test_command.trim() !== "") {
+        testCmd = guardTestCommand(input.test_command, config);
+        // guardTestCommand throws if not in allowedTestCommands
+    }
+    if (input.verify_commands !== undefined && !Array.isArray(input.verify_commands)) {
+        throw new PatchWardenError("invalid_verify_commands", "verify_commands must be an array of allow-listed command strings.", "Pass an array such as [\"npm test\", \"npm run build\"].");
+    }
+    if ((input.verify_commands?.length || 0) > 20) {
+        throw new PatchWardenError("invalid_verify_commands", "verify_commands cannot contain more than 20 commands.", "Keep verification focused and use no more than 20 allow-listed commands.");
+    }
+    const verifyCommands = [...new Set([
+            ...(input.verify_commands || []).map((command) => guardTestCommand(command, config)),
+            ...(testCmd ? [testCmd] : []),
+        ])];
+    const timeoutSeconds = input.timeout_seconds ?? config.defaultTaskTimeoutSeconds;
+    if (!Number.isInteger(timeoutSeconds) || timeoutSeconds <= 0) {
+        throw new PatchWardenError("invalid_timeout", "timeout_seconds must be a positive integer", `Use a whole number from 1 to ${config.maxTaskTimeoutSeconds}.`);
+    }
+    if (timeoutSeconds > config.maxTaskTimeoutSeconds) {
+        throw new PatchWardenError("invalid_timeout", `timeout_seconds cannot exceed configured maximum ${config.maxTaskTimeoutSeconds}`, `Use a value no greater than ${config.maxTaskTimeoutSeconds}.`);
+    }
+    let planId = input.plan_id?.trim() || "";
+    let planSource = "saved";
+    let changePolicy = "repo_scoped_changes";
+    if (planId) {
+        const planFile = join(resolve(plansDir, planId), "plan.md");
+        guardReadPath(planFile, config.workspaceRoot, config.plansDir);
+        if (!existsSync(planFile)) {
+            throw new PatchWardenError("plan_not_found", `Plan "${planId}" not found.`, "Call save_plan first, or pass inline_plan/template directly to create_task.");
+        }
+    }
+    else if (input.inline_plan?.trim()) {
+        const saved = savePlan({
+            title: input.plan_title?.trim() || "Inline task plan",
+            content: input.inline_plan.trim(),
+        });
+        planId = saved.plan_id;
+        planSource = "inline";
+    }
+    else {
+        const expanded = expandTaskTemplate({
+            template: input.template,
+            goal: input.goal || "",
+            source_task_id: input.source_task_id,
+            verify_commands: verifyCommands,
+        });
+        const saved = savePlan({ title: expanded.title, content: expanded.content });
+        planId = saved.plan_id;
+        planSource = "template";
+        changePolicy = expanded.change_policy;
+    }
+    const taskId = `task_${Date.now()}_${planId.replace(/^plan_/, "")}`;
+    const taskDir = resolve(tasksDir, taskId);
+    guardPath(taskDir, config.workspaceRoot, config.tasksDir);
+    mkdirSync(taskDir, { recursive: true });
+    const status = "pending";
+    const statusFile = join(taskDir, "status.json");
+    const statusData = {
+        task_id: taskId,
+        plan_id: planId,
+        plan_source: planSource,
+        template: input.template || null,
+        change_policy: changePolicy,
+        agent: input.agent,
+        workspace_root: resolve(config.workspaceRoot),
+        repo_path: resolvedRepoPath,
+        resolved_repo_path: safeRepoPath,
+        test_command: testCmd,
+        verify_commands: verifyCommands,
+        timeout_seconds: timeoutSeconds,
+        status,
+        phase: "queued",
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        last_heartbeat_at: new Date().toISOString(),
+        current_command: null,
+        error: null,
+    };
+    writeFileSync(statusFile, JSON.stringify(statusData, null, 2), "utf-8");
+    writeTaskProgress(taskDir, "queued", {
+        heartbeatAt: statusData.last_heartbeat_at,
+        note: `Waiting for watcher. Timeout: ${timeoutSeconds} seconds.`,
+    });
+    const catalog = getLastToolCatalogSnapshot();
+    const watcher = readWatcherStatus(config);
+    const pendingReason = derivePendingReason({ status, phase: statusData.phase }, watcher);
+    const hasWaitForTask = catalog?.tool_names?.includes("wait_for_task") ?? true;
+    const nextActionWait = `Call wait_for_task with task_id ${taskId}; keep calling it until terminal is true, then review the returned summary.`;
+    const nextActionPoll = `Task created. Monitor status with get_task_status(task_id: "${taskId}") and check progress.md. When status reaches done/failed, review get_task_summary or get_result.`;
+    const nextActionBlocked = `Task was saved but execution is blocked because the watcher is ${watcher.status}. Call health_check and restart the owned watcher; the queued task will be picked up after recovery.`;
+    const followupCandidates = ["health_check", "get_task_status", "list_tasks", "wait_for_task", "cancel_task"];
+    const availableFollowupTools = catalog
+        ? followupCandidates.filter((name) => catalog.tool_names.includes(name))
+        : followupCandidates;
+    return {
+        task_id: taskId,
+        plan_id: planId,
+        agent: input.agent,
+        status,
+        timeout_seconds: timeoutSeconds,
+        continuation_required: watcher.available && hasWaitForTask,
+        next_action: !watcher.available ? nextActionBlocked : hasWaitForTask ? nextActionWait : nextActionPoll,
+        path: taskDir,
+        plan_source: planSource,
+        ...(input.template ? { template: input.template } : {}),
+        change_policy: changePolicy,
+        server_version: PATCHWARDEN_VERSION,
+        tool_profile: catalog?.tool_profile || resolveToolProfile(config.toolProfile),
+        tool_manifest_sha256: catalog?.tool_manifest_sha256 || null,
+        execution_blocked: !watcher.available,
+        pending_reason: pendingReason,
+        watcher,
+        available_followup_tools: availableFollowupTools,
+        next_tool_call: !watcher.available
+            ? { name: "health_check", arguments: { detail: "standard" } }
+            : hasWaitForTask
+                ? { name: "wait_for_task", arguments: { task_id: taskId, timeout_seconds: 25 } }
+                : { name: "get_task_status", arguments: { task_id: taskId } },
+    };
+}

package/dist/tools/getPlan.d.ts

@@ -0,0 +1,12 @@
+export interface GetPlanInput {
+    plan_id: string;
+}
+export interface GetPlanOutput {
+    plan_id: string;
+    title: string;
+    content: string;
+    path: string;
+    redacted?: boolean;
+    redaction_categories?: string[];
+}
+export declare function getPlan(input: GetPlanInput): GetPlanOutput;

package/dist/tools/getPlan.js

@@ -0,0 +1,29 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { getPlansDir, getConfig } from "../config.js";
+import { guardReadPath } from "../security/pathGuard.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+import { redactSensitiveContent } from "../security/contentRedaction.js";
+export function getPlan(input) {
+    const config = getConfig();
+    const plansDir = getPlansDir(config);
+    // Restrict to plans directory only
+    const planDir = resolve(plansDir, input.plan_id);
+    const planFile = join(planDir, "plan.md");
+    guardReadPath(planFile, config.workspaceRoot, config.plansDir);
+    guardSensitivePath(planFile);
+    if (!existsSync(planFile)) {
+        throw new Error(`Plan not found: "${input.plan_id}". Check the plan ID or save a plan first.`);
+    }
+    const raw = readFileSync(planFile, "utf-8");
+    const redaction = redactSensitiveContent(raw);
+    const titleLine = raw.split("\n")[0]?.replace(/^#\s*/, "") || input.plan_id;
+    return {
+        plan_id: input.plan_id,
+        title: titleLine,
+        content: redaction.content,
+        path: planFile,
+        redacted: redaction.redacted,
+        redaction_categories: redaction.redaction_categories,
+    };
+}

package/dist/tools/getTaskFile.d.ts

@@ -0,0 +1,24 @@
+export interface GetTaskFileOutput {
+    task_id: string;
+    filename: string;
+    content: string;
+    path: string;
+    available: boolean;
+    reason?: "task_not_terminal" | "artifact_missing";
+    task_status?: string;
+    phase?: string;
+    pending_reason?: string | null;
+    watcher?: unknown;
+    next_action?: string;
+    next_tool_call?: {
+        name: string;
+        arguments: Record<string, unknown>;
+    };
+    redacted?: boolean;
+    redaction_categories?: string[];
+}
+export declare const TASK_READ_ONLY_FILES: string[];
+/**
+ * Read a task output file: result.md, git.diff, test.log, etc.
+ */
+export declare function getTaskFile(taskId: string, filename: string): GetTaskFileOutput;

package/dist/tools/getTaskFile.js

@@ -0,0 +1,84 @@
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { getTasksDir, getConfig } from "../config.js";
+import { guardPath } from "../security/pathGuard.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+import { redactSensitiveContent } from "../security/contentRedaction.js";
+import { getTaskStatus } from "./getTaskStatus.js";
+export const TASK_READ_ONLY_FILES = [
+    "result.md",
+    "result.json",
+    "git.diff",
+    "diff.patch",
+    "test.log",
+    "verify.log",
+    "verify.json",
+    "status.json",
+    "plan.md",
+    "error.log",
+    "stdout.log",
+    "stderr.log",
+    "progress.md",
+    "changed-files.json",
+    "file-stats.json",
+    "rollback-plan.json",
+    "rollback_scope_violation_plan.md",
+];
+/**
+ * Read a task output file: result.md, git.diff, test.log, etc.
+ */
+export function getTaskFile(taskId, filename) {
+    const config = getConfig();
+    const tasksDir = getTasksDir(config);
+    // Only allow known filenames
+    if (!TASK_READ_ONLY_FILES.includes(filename)) {
+        throw new Error(`File "${filename}" is not allowed. Allowed: ${TASK_READ_ONLY_FILES.join(", ")}`);
+    }
+    const taskDir = resolve(tasksDir, taskId);
+    const filePath = join(taskDir, filename);
+    guardPath(filePath, config.workspaceRoot, config.tasksDir);
+    guardSensitivePath(filePath);
+    if (!existsSync(filePath)) {
+        const status = getTaskStatus(taskId);
+        const terminal = !["pending", "running"].includes(status.status);
+        const watcherBlocked = status.status === "pending" && !status.watcher.available;
+        return {
+            task_id: taskId,
+            filename,
+            content: "",
+            path: filePath,
+            available: false,
+            reason: terminal ? "artifact_missing" : "task_not_terminal",
+            task_status: status.status,
+            phase: status.phase,
+            pending_reason: status.pending_reason,
+            watcher: status.watcher,
+            next_action: terminal
+                ? `The task is terminal but ${filename} is missing. Review get_task_summary and audit_task warnings.`
+                : watcherBlocked
+                    ? "The task is queued but the watcher is unavailable. Call health_check and restart the owned watcher."
+                    : "The task is still running or queued. Call wait_for_task or get_task_status before reading this artifact.",
+            next_tool_call: terminal
+                ? { name: "get_task_summary", arguments: { task_id: taskId } }
+                : watcherBlocked
+                    ? { name: "health_check", arguments: { detail: "standard" } }
+                    : { name: "wait_for_task", arguments: { task_id: taskId, timeout_seconds: 25 } },
+            redacted: false,
+            redaction_categories: [],
+        };
+    }
+    const stat = statSync(filePath);
+    if (stat.size > config.maxReadFileBytes) {
+        throw new Error(`File "${filename}" is ${stat.size} bytes, exceeds max of ${config.maxReadFileBytes} bytes.`);
+    }
+    const redaction = redactSensitiveContent(readFileSync(filePath, "utf-8"));
+    return {
+        task_id: taskId,
+        filename,
+        content: redaction.content,
+        path: filePath,
+        available: true,
+        redacted: redaction.redacted,
+        redaction_categories: redaction.redaction_categories,
+    };
+}

package/dist/tools/getTaskProgress.d.ts

@@ -0,0 +1 @@
+export declare function getTaskProgress(taskId: string): import("./getTaskFile.js").GetTaskFileOutput;

package/dist/tools/getTaskProgress.js

@@ -0,0 +1,4 @@
+import { getTaskFile } from "./getTaskFile.js";
+export function getTaskProgress(taskId) {
+    return getTaskFile(taskId, "progress.md");
+}

package/dist/tools/getTaskStatus.d.ts

@@ -0,0 +1,46 @@
+import type { TaskStatus } from "./createTask.js";
+import type { TaskPhase } from "./createTask.js";
+import { type PendingReason, type WatcherStatusSnapshot } from "../watcherStatus.js";
+export interface GetTaskStatusOutput {
+    task_id: string;
+    plan_id: string;
+    plan_source?: "saved" | "inline" | "template";
+    template?: string | null;
+    change_policy?: "repo_scoped_changes" | "no_changes";
+    agent: string;
+    workspace_root: string;
+    repo_path: string;
+    resolved_repo_path: string;
+    status: TaskStatus;
+    phase: TaskPhase;
+    created_at: string;
+    updated_at: string;
+    last_heartbeat_at: string;
+    current_command: string | null;
+    timeout_seconds: number;
+    started_at?: string;
+    finished_at?: string;
+    changed_files?: Array<{
+        path: string;
+        change: string;
+    }>;
+    out_of_scope_changes?: Array<{
+        path: string;
+        change: string;
+    }>;
+    verify_status?: "passed" | "failed" | "skipped";
+    verify_commands?: string[];
+    diff_available?: boolean;
+    diff_truncated?: boolean;
+    workspace_dirty_before?: boolean;
+    workspace_dirty_after?: boolean;
+    workspace_dirty?: boolean;
+    error: string | null;
+    watcher_status: WatcherStatusSnapshot["status"];
+    watcher_last_heartbeat_at: string | null;
+    watcher_heartbeat_age_seconds: number | null;
+    watcher: WatcherStatusSnapshot;
+    pending_reason: PendingReason;
+    execution_blocked: boolean;
+}
+export declare function getTaskStatus(taskId: string): GetTaskStatusOutput;

package/dist/tools/getTaskStatus.js

@@ -0,0 +1,36 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { getTasksDir, getConfig } from "../config.js";
+import { guardReadPath } from "../security/pathGuard.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+import { readTaskRuntime } from "../taskRuntime.js";
+import { derivePendingReason, readWatcherStatus, } from "../watcherStatus.js";
+export function getTaskStatus(taskId) {
+    const config = getConfig();
+    const tasksDir = getTasksDir(config);
+    const taskDir = resolve(tasksDir, taskId);
+    const statusFile = join(taskDir, "status.json");
+    guardReadPath(statusFile, config.workspaceRoot, config.tasksDir);
+    guardSensitivePath(statusFile);
+    if (!existsSync(statusFile)) {
+        throw new Error(`Task not found: "${taskId}". Check the task ID or create a task first.`);
+    }
+    const raw = readFileSync(statusFile, "utf-8");
+    const status = JSON.parse(raw);
+    const runtime = readTaskRuntime(taskDir);
+    const phase = runtime.phase || status.phase || "queued";
+    const watcher = readWatcherStatus(config);
+    const pendingReason = derivePendingReason({ status: status.status, phase }, watcher);
+    return {
+        ...status,
+        phase,
+        last_heartbeat_at: runtime.last_heartbeat_at || status.last_heartbeat_at || status.updated_at,
+        current_command: runtime.current_command ?? status.current_command ?? null,
+        watcher_status: watcher.status,
+        watcher_last_heartbeat_at: watcher.last_heartbeat_at,
+        watcher_heartbeat_age_seconds: watcher.heartbeat_age_seconds,
+        watcher,
+        pending_reason: pendingReason,
+        execution_blocked: status.status === "pending" && !watcher.available,
+    };
+}

package/dist/tools/getTaskStdoutTail.d.ts

@@ -0,0 +1,9 @@
+export declare function getTaskStdoutTail(taskId: string, lines?: number): {
+    task_id: string;
+    lines: number;
+    stdout_tail: string;
+    stderr_tail: string;
+    source: string;
+    redacted: boolean;
+    redaction_categories: string[];
+};

package/dist/tools/getTaskStdoutTail.js

@@ -0,0 +1,56 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { getTasksDir, getConfig } from "../config.js";
+import { guardReadPath } from "../security/pathGuard.js";
+import { redactSensitiveContent } from "../security/contentRedaction.js";
+export function getTaskStdoutTail(taskId, lines = 80) {
+    const config = getConfig();
+    const tasksDir = getTasksDir(config);
+    const taskDir = join(tasksDir, taskId);
+    const statusFile = join(taskDir, "status.json");
+    // First verify the task exists
+    guardReadPath(statusFile, config.workspaceRoot, config.tasksDir);
+    if (!existsSync(statusFile)) {
+        throw new Error(`Task not found: "${taskId}"`);
+    }
+    const stdoutLog = join(taskDir, "stdout.log");
+    const stderrLog = join(taskDir, "stderr.log");
+    const resultFile = join(taskDir, "result.md");
+    const maxLines = Math.min(lines, 200);
+    let stdoutTail = "";
+    let stderrTail = "";
+    let source = "none";
+    // All log files are optional — don't throw if missing
+    if (existsSync(stdoutLog)) {
+        const raw = readFileSync(stdoutLog, "utf-8");
+        stdoutTail = raw.split("\n").slice(-maxLines).join("\n");
+        source = "stdout.log";
+    }
+    if (existsSync(stderrLog)) {
+        const raw = readFileSync(stderrLog, "utf-8");
+        stderrTail = raw.split("\n").slice(-Math.min(maxLines, 40)).join("\n");
+    }
+    // Fallback to result.md
+    if (!stdoutTail && existsSync(resultFile)) {
+        const raw = readFileSync(resultFile, "utf-8");
+        const stdoutMatch = raw.match(/## Agent stdout\s*\n+```\s*([\s\S]*?)```/i);
+        const stderrMatch = raw.match(/## Agent stderr\s*\n+```\s*([\s\S]*?)```/i);
+        if (stdoutMatch)
+            stdoutTail = stdoutMatch[1].split("\n").slice(-maxLines).join("\n");
+        if (stderrMatch && !stderrTail)
+            stderrTail = stderrMatch[1].split("\n").slice(-Math.min(maxLines, 40)).join("\n");
+        if (source === "none")
+            source = "result.md";
+    }
+    const stdoutRedacted = redactSensitiveContent(stdoutTail || "(no output yet — task may be pending or not started)");
+    const stderrRedacted = redactSensitiveContent(stderrTail || "(no stderr)");
+    return {
+        task_id: taskId,
+        lines: stdoutTail ? stdoutTail.split("\n").length : 0,
+        stdout_tail: stdoutRedacted.content,
+        stderr_tail: stderrRedacted.content,
+        source,
+        redacted: stdoutRedacted.redacted || stderrRedacted.redacted,
+        redaction_categories: [...new Set([...stdoutRedacted.redaction_categories, ...stderrRedacted.redaction_categories])],
+    };
+}

package/dist/tools/getTaskSummary.d.ts

@@ -0,0 +1,66 @@
+export interface TaskSummaryOutput {
+    task_id: string;
+    status: string;
+    terminal: boolean;
+    acceptance_status: "pending" | "ready_for_review" | "needs_review" | "failed";
+    acceptance_reviewed_at: string | null;
+    acceptance_reviewer: string | null;
+    phase: string;
+    agent: string;
+    workspace_root: string;
+    repo_path: string;
+    resolved_repo_path: string;
+    changed_files: unknown[];
+    out_of_scope_changes: unknown[];
+    workspace_dirty_before: boolean;
+    workspace_dirty_after: boolean;
+    verify_status: string;
+    verify_commands: unknown[];
+    last_heartbeat_at: string;
+    current_command: string | null;
+    elapsed_ms: number;
+    summary: string;
+    test_summary: string;
+    diff_available: boolean;
+    diff_truncated: boolean;
+    result_available: boolean;
+    result_json_available: boolean;
+    verify_available: boolean;
+    test_log_available: boolean;
+    warnings: string[];
+    errors: string[];
+    artifacts: Record<string, boolean>;
+    plan_source: string;
+    template: string | null;
+    change_policy: string;
+    failure_reason: string | null;
+    failed_command: string | null;
+    suggested_next_action: string;
+    safe_followup_prompt: string | null;
+    verification_summary: {
+        status: string;
+        command_count: number;
+        passed_commands: number;
+        failed_commands: number;
+        skipped_commands: number;
+        headline: string;
+    };
+    failed_command_detail: {
+        command: string;
+        exit_code: number | null;
+        stderr_tail: string;
+        duration_ms: number;
+    } | null;
+    log_tails: {
+        stdout: string;
+        stderr: string;
+        test: string;
+        verify: string;
+    };
+    redacted: boolean;
+    redaction_categories: string[];
+    watcher: unknown;
+    pending_reason: string | null;
+    execution_blocked: boolean;
+}
+export declare function getTaskSummary(taskId: string): TaskSummaryOutput;