patchwarden 1.5.1 → 1.6.1

package/dist/control/routes/status.d.ts

@@ -1,6 +1,51 @@
 import { type ServerResponse } from "node:http";
+import { type AgentAvailability } from "../../tools/workspace/listAgents.js";
+import { type WatcherStatusSnapshot } from "../../watcherStatus.js";
+import { type RuntimeHealth, type StatusTasks } from "../runtime.js";
+interface Suggestion {
+    code: string;
+    severity: "info" | "warning" | "error";
+    message: string;
+    action?: string;
+    link?: string;
+}
+interface StatusSnapshotForSuggestions {
+    core: RuntimeHealth;
+    direct: RuntimeHealth;
+    watcher: WatcherStatusSnapshot;
+    tunnel: {
+        core: Record<string, unknown>;
+        direct: Record<string, unknown>;
+    };
+    agents: AgentAvailability[];
+    tasks: StatusTasks;
+    direct_profile_enabled: boolean;
+}
+export interface ExperienceStatus {
+    readiness: "ready" | "needs_action" | "blocked";
+    live_checks: Array<{
+        key: string;
+        label: string;
+        state: "ready" | "needs_action" | "blocked" | "optional";
+        detail: string;
+    }>;
+    historical_summary: {
+        stale_tasks: number;
+        failed_tasks: number;
+        note: string;
+    };
+}
+/**
+ * Keep current readiness separate from historical evidence. A month-old failed
+ * task is useful for audit, but must not make a configured local bridge look
+ * unavailable on the first screen.
+ */
+export declare function buildExperienceStatus(snapshot: StatusSnapshotForSuggestions): ExperienceStatus;
+export declare function reconcileTunnelStatus(status: Record<string, unknown>, health: RuntimeHealth): Record<string, unknown>;
+export declare function buildSuggestions(s: StatusSnapshotForSuggestions): Suggestion[];
 export declare function handleStatus(res: ServerResponse): Promise<void>;
 export declare function handleControlCenterStatus(res: ServerResponse): void;
 export declare function handleEvents(res: ServerResponse, limit: number): void;
 export declare function handleTunnelUiUrl(res: ServerResponse): void;
-export declare function handleDiagnostics(res: ServerResponse): void;
+export declare function handleDiagnostics(res: ServerResponse): Promise<void>;
+export {};

package/dist/control/routes/status.js

@@ -12,8 +12,54 @@ import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../../version.js";
 import { redactSensitiveValue } from "../../security/contentRedaction.js";
 import { listAgentsSafe, listTasksForStatus, probeRuntimeHealth, readEvents, recordEvent, readToolManifest, readTunnelStatus, readTunnelUrl, readWatcherStatusSafe, resolveWorkspaceRootSafe, } from "../runtime.js";
 import { findTunnelClientExecutable } from "./process.js";
-import { config, controlCenterStatusPath, CORE_BASE_URL, DEFAULT_TUNNEL_CLIENT_EXE, DIRECT_BASE_URL, errorMessage, readJsonFileSafe, sendJson, } from "../shared.js";
-function buildSuggestions(s) {
+import { config, configIdentitySha256, controlCenterStatusPath, CORE_BASE_URL, DIRECT_BASE_URL, errorMessage, readJsonFileSafe, sendJson, } from "../shared.js";
+/**
+ * Keep current readiness separate from historical evidence. A month-old failed
+ * task is useful for audit, but must not make a configured local bridge look
+ * unavailable on the first screen.
+ */
+export function buildExperienceStatus(snapshot) {
+    const coreReady = snapshot.core.available && snapshot.tunnel.core.ready === true;
+    const watcherReady = snapshot.watcher.status === "healthy";
+    const agentsReady = snapshot.agents.some((agent) => agent.available);
+    const directEnabled = snapshot.direct_profile_enabled;
+    const directReady = snapshot.direct.available && snapshot.tunnel.direct.ready === true;
+    const staleTasks = snapshot.tasks.stale;
+    const failedTasks = snapshot.tasks.tasks.filter((task) => String(task.status || "").includes("failed")).length;
+    const live_checks = [
+        { key: "workspace_agents", label: "工作区与 Agent", state: agentsReady ? "ready" : "blocked", detail: agentsReady ? "工作区内至少有一个可用 Agent" : "需要配置工作区或可用 Agent" },
+        { key: "core", label: "Core 服务", state: coreReady ? "ready" : "needs_action", detail: coreReady ? "Core 与 Tunnel 已就绪" : "启动 Core 后会继续检查 Tunnel 与 Watcher" },
+        { key: "watcher", label: "任务监视器", state: watcherReady ? "ready" : "needs_action", detail: watcherReady ? "Watcher 心跳正常" : "Core 启动后 Watcher 将处理排队任务" },
+        { key: "direct", label: "Direct 编辑", state: directEnabled ? (directReady ? "ready" : "needs_action") : "optional", detail: directEnabled ? (directReady ? "Direct 已就绪" : "已启用但尚未就绪") : "可选高级能力，未启用不会影响 Core" },
+    ];
+    const readiness = !agentsReady
+        ? "blocked"
+        : coreReady && watcherReady && (!directEnabled || directReady)
+            ? "ready"
+            : "needs_action";
+    return {
+        readiness,
+        live_checks,
+        historical_summary: {
+            stale_tasks: staleTasks,
+            failed_tasks: failedTasks,
+            note: "历史任务与审计记录不会影响当前实时就绪状态。",
+        },
+    };
+}
+export function reconcileTunnelStatus(status, health) {
+    if (!health.available)
+        return status;
+    return {
+        ...status,
+        observed: true,
+        status: "running",
+        ready: true,
+        reason_code: "health_endpoint_ready",
+        health_observed: true,
+    };
+}
+export function buildSuggestions(s) {
     const out = [];
     if (!s.core.available) {
         out.push({
@@ -23,7 +69,7 @@ function buildSuggestions(s) {
             action: "/api/core/start",
         });
     }
-    if (!s.direct.available) {
+    if (s.direct_profile_enabled && !s.direct.available) {
         out.push({
             code: "direct_stopped",
             severity: "warning",
@@ -31,12 +77,12 @@ function buildSuggestions(s) {
             action: "/api/direct/start",
         });
     }
-    if (s.watcher.status === "stale" || s.watcher.status === "unreadable") {
+    if (s.watcher.status === "degraded" || s.watcher.status === "stale" || s.watcher.status === "unreadable") {
         out.push({
             code: "watcher_stale",
             severity: "error",
-            message: "Watcher 处于 " + s.watcher.status + " 状态，建议 Restart All",
-            action: "/api/restart-all",
+            message: "Watcher 处于 " + s.watcher.status + " 状态，建议重启 Core",
+            action: "/api/core/restart",
         });
     }
     if (s.tasks.stale > 0) {
@@ -49,12 +95,12 @@ function buildSuggestions(s) {
     }
     const coreTunnelReady = !!(s.tunnel.core && s.tunnel.core.ready);
     const directTunnelReady = !!(s.tunnel.direct && s.tunnel.direct.ready);
-    if (!coreTunnelReady || !directTunnelReady) {
+    if (!coreTunnelReady || (s.direct_profile_enabled && !directTunnelReady)) {
         out.push({
             code: "tunnel_not_ready",
             severity: "warning",
-            message: "Tunnel 未就绪，建议重启 profile 或检查代理",
-            action: "/api/restart-all",
+            message: "Tunnel 未就绪，建议启动 profile 或检查代理",
+            action: "/api/start-all",
         });
     }
     const missingAgents = s.agents.filter((a) => !a.available);
@@ -62,7 +108,7 @@ function buildSuggestions(s) {
         out.push({
             code: "agent_missing",
             severity: "info",
-            message: "Agent 未就绪：" + missingAgents.map((a) => a.name).join(", ") + "（请检查 opencode/claude 路径）",
+            message: "Agent 未就绪：" + missingAgents.map((a) => a.name).join(", ") + "（请检查对应 CLI 安装与路径）",
         });
     }
     return out;
@@ -101,7 +147,7 @@ function diffAndRecordEvents(prev, curr) {
 // ── Handlers ──────────────────────────────────────────────────────
 export async function handleStatus(res) {
     try {
-        const [coreHealth, directHealth, watcher, tunnelCore, tunnelDirect, toolsCore, toolsDirect, agents, workspaceRoot, tasks] = await Promise.all([
+        const [coreHealth, directHealth, watcher, tunnelCoreRaw, tunnelDirectRaw, toolsCore, toolsDirect, agents, workspaceRoot, tasks] = await Promise.all([
             probeRuntimeHealth(CORE_BASE_URL).catch((err) => ({
                 available: false,
                 reason: errorMessage(err),
@@ -123,6 +169,8 @@ export async function handleStatus(res) {
             Promise.resolve(resolveWorkspaceRootSafe()),
             Promise.resolve(listTasksForStatus()),
         ]);
+        const tunnelCore = reconcileTunnelStatus(tunnelCoreRaw, coreHealth);
+        const tunnelDirect = reconcileTunnelStatus(tunnelDirectRaw, directHealth);
         const snapshotForSuggestions = {
             core: coreHealth,
             direct: directHealth,
@@ -130,8 +178,10 @@ export async function handleStatus(res) {
             tunnel: { core: tunnelCore, direct: tunnelDirect },
             agents,
             tasks,
+            direct_profile_enabled: config.enableDirectProfile === true,
         };
         const suggestions = buildSuggestions(snapshotForSuggestions);
+        const experience = buildExperienceStatus(snapshotForSuggestions);
         const tunnelClientExe = findTunnelClientExecutable();
         // Diff against the previous poll to record observed state-change events.
         // This is the only place that observes Core/Direct/watcher/task transitions
@@ -151,11 +201,13 @@ export async function handleStatus(res) {
             workspace_root: workspaceRoot,
             tasks,
             suggestions,
+            experience,
+            direct_profile_enabled: config.enableDirectProfile === true,
             setup: {
                 tunnel_client: {
                     available: tunnelClientExe !== null,
                     path: tunnelClientExe,
-                    default_path: DEFAULT_TUNNEL_CLIENT_EXE,
+                    source: config.tunnelClientPath && tunnelClientExe === config.tunnelClientPath ? "config" : "detected",
                 },
                 workspace_root: workspaceRoot,
                 watcher: {
@@ -197,11 +249,15 @@ export function handleTunnelUiUrl(res) {
         direct: readTunnelUrl(true),
     });
 }
-export function handleDiagnostics(res) {
+export async function handleDiagnostics(res) {
     try {
         const watcher = readWatcherStatusSafe();
-        const tunnelCore = readTunnelStatus(false);
-        const tunnelDirect = readTunnelStatus(true);
+        const [coreHealth, directHealth] = await Promise.all([
+            probeRuntimeHealth(CORE_BASE_URL),
+            probeRuntimeHealth(DIRECT_BASE_URL),
+        ]);
+        const tunnelCore = reconcileTunnelStatus(readTunnelStatus(false), coreHealth);
+        const tunnelDirect = reconcileTunnelStatus(readTunnelStatus(true), directHealth);
         const toolsCore = readToolManifest(false);
         const toolsDirect = readToolManifest(true);
         const agents = listAgentsSafe();
@@ -239,6 +295,7 @@ export function handleDiagnostics(res) {
             workspace_root: workspaceRoot,
             recent_failures: recentFailures,
             direct_profile_enabled: config.enableDirectProfile ?? false,
+            config_identity_sha256: configIdentitySha256,
         };
         // Redact any sensitive content that may have leaked into string fields.
         const redacted = redactSensitiveValue(diagnostics);

package/dist/control/routes/taskActions.js

@@ -7,13 +7,15 @@
  * dashboard. None of them delete task files; they annotate or launch external
  * viewers.
  */
-import { existsSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { auditTask } from "../../tools/auditTask.js";
+import { auditTask } from "../../tools/diagnostics/auditTask.js";
 import { getTasksDir } from "../../config.js";
-import { classifyStaleTask, isValidTaskId, readHiddenStaleIds, readWatcherStatusSafe, recordEvent, TERMINAL_TASK_STATUSES, writeHiddenStaleIds, } from "../runtime.js";
-import { config, errorMessage, readJsonFileSafe, sendJson } from "../shared.js";
+import { classifyStaleTask, isValidTaskId, readHiddenStaleIds, reconstructTaskEntry, readWatcherStatusSafe, recordEvent, TERMINAL_TASK_STATUSES, writeHiddenStaleIds, } from "../runtime.js";
+import { launchFileManager } from "../fileManager.js";
+import { config, errorMessage, guardControlPath, readJsonFileSafe, sendJson } from "../shared.js";
+import { atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
+import { mutateTaskStatus } from "../../runner/taskStatusStore.js";
 /**
  * Reconcile a stale task. Does NOT delete the task. Reads the task files,
  * decides whether it is safe to mark the task as stale/archived, writes a
@@ -27,8 +29,8 @@ export function handleReconcile(res, taskId) {
             return;
         }
         const tasksDir = getTasksDir(config);
-        const taskDir = join(tasksDir, taskId);
-        if (!existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
+        const taskDir = guardControlPath(join(tasksDir, taskId), config.tasksDir);
+        if (!taskDir || !existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
             sendJson(res, 404, { error: "Task not found" });
             return;
         }
@@ -37,33 +39,7 @@ export function handleReconcile(res, taskId) {
         const statusData = readJsonFileSafe(statusPath) ?? {};
         const runtimeData = readJsonFileSafe(runtimePath) ?? {};
         const watcher = readWatcherStatusSafe();
-        const VALID_ACCEPTANCE = ["pending", "accepted", "rejected", "needs_fix", "blocked"];
-        const taskStatus = String(statusData.status || "pending");
-        const taskAcceptanceStatus = taskStatus === "done_by_agent"
-            ? (typeof statusData.acceptance_status === "string" && VALID_ACCEPTANCE.includes(statusData.acceptance_status) ? statusData.acceptance_status : "pending")
-            : null;
-        const taskEntry = {
-            task_id: taskId,
-            plan_id: String(statusData.plan_id || ""),
-            title: "",
-            agent: String(statusData.agent || ""),
-            status: taskStatus,
-            phase: String(runtimeData.phase || statusData.phase || "queued"),
-            acceptance_status: taskAcceptanceStatus,
-            created_at: String(statusData.created_at || ""),
-            updated_at: String(statusData.updated_at || ""),
-            workspace_root: String(statusData.workspace_root || config.workspaceRoot),
-            repo_path: String(statusData.repo_path || "."),
-            resolved_repo_path: String(statusData.resolved_repo_path || statusData.repo_path || config.workspaceRoot),
-            test_command: String(statusData.test_command || ""),
-            verify_commands: Array.isArray(statusData.verify_commands) ? statusData.verify_commands : [],
-            error: statusData.error ? String(statusData.error) : null,
-            last_heartbeat_at: String(runtimeData.last_heartbeat_at || statusData.last_heartbeat_at || statusData.updated_at || ""),
-            current_command: runtimeData.current_command === undefined ? null : String(runtimeData.current_command || "") || null,
-            timeout_seconds: Number(statusData.timeout_seconds) || config.defaultTaskTimeoutSeconds,
-            pending_reason: null,
-            watcher_status: watcher.status,
-        };
+        const taskEntry = reconstructTaskEntry(taskId, statusData, runtimeData, watcher);
         const cls = classifyStaleTask(taskEntry, watcher);
         const isTerminal = TERMINAL_TASK_STATUSES.has(taskEntry.status);
         // Safe to mark stale/archived when:
@@ -104,7 +80,7 @@ export function handleReconcile(res, taskId) {
         };
         // Write the reconcile record artifact.
         try {
-            writeFileSync(join(taskDir, "reconcile.json"), JSON.stringify(reconcileRecord, null, 2), "utf-8");
+            atomicWriteJsonFileSync(join(taskDir, "reconcile.json"), reconcileRecord);
         }
         catch (writeErr) {
             sendJson(res, 500, { error: `Failed to write reconcile record: ${errorMessage(writeErr)}` });
@@ -112,13 +88,18 @@ export function handleReconcile(res, taskId) {
         }
         // Annotate status.json with reconcile metadata (do not mutate status enum).
         if (safe) {
-            const annotated = {
-                ...statusData,
+            const annotation = {
                 reconcile_state: decision === "marked_archived" ? "archived" : "stale",
                 reconciled_at: reconciledAt,
             };
             try {
-                writeFileSync(statusPath, JSON.stringify(annotated, null, 2), "utf-8");
+                mutateTaskStatus(statusPath, (current) => {
+                    if (current.status !== taskEntry.status) {
+                        throw new Error("Task status changed while reconcile was being evaluated; retry.");
+                    }
+                    const next = { ...current, ...annotation, updated_at: new Date().toISOString() };
+                    return { next, result: next };
+                });
             }
             catch (writeErr) {
                 sendJson(res, 500, { error: `Failed to annotate status.json: ${errorMessage(writeErr)}` });
@@ -150,8 +131,8 @@ export function handleTaskAudit(res, taskId) {
             return;
         }
         const tasksDir = getTasksDir(config);
-        const taskDir = join(tasksDir, taskId);
-        if (!existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
+        const taskDir = guardControlPath(join(tasksDir, taskId), config.tasksDir);
+        if (!taskDir || !existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
             sendJson(res, 404, { error: "Task not found" });
             return;
         }
@@ -179,29 +160,12 @@ export function handleOpenTaskFolder(res, taskId) {
             return;
         }
         const tasksDir = getTasksDir(config);
-        const taskDir = join(tasksDir, taskId);
-        if (!existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
+        const taskDir = guardControlPath(join(tasksDir, taskId), config.tasksDir);
+        if (!taskDir || !existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
             sendJson(res, 404, { error: "Task not found" });
             return;
         }
-        let cmd;
-        if (process.platform === "win32") {
-            cmd = "explorer.exe";
-        }
-        else if (process.platform === "darwin") {
-            cmd = "open";
-        }
-        else {
-            cmd = "xdg-open";
-        }
-        try {
-            const child = spawn(cmd, [taskDir], { detached: true, stdio: "ignore" });
-            child.on("error", () => { });
-            child.unref();
-        }
-        catch {
-            /* ignore */
-        }
+        launchFileManager(taskDir, tasksDir);
         sendJson(res, 200, { ok: true, path: taskDir });
     }
     catch (err) {

package/dist/control/routes/tasks.d.ts

@@ -5,6 +5,10 @@ export interface TaskFilters {
     acceptance_status?: string;
     agent?: string;
     warning_type?: string;
+    date_from?: string;
+    date_to?: string;
+    limit?: number;
+    cursor?: string;
 }
 export declare function handleTasks(res: ServerResponse, filters?: TaskFilters): void;
 export declare function deriveStaleReasonCode(staleReasons: string[]): string;

package/dist/control/routes/tasks.js

@@ -9,17 +9,18 @@
  */
 import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { listTasks } from "../../tools/listTasks.js";
-import { safeAudit, safeDiffSummary, safeResult, safeTestSummary } from "../../tools/safeViews.js";
+import { listTasks } from "../../tools/tasks/listTasks.js";
+import { safeAudit, safeDiffSummary, safeResult, safeTestSummary } from "../../tools/diagnostics/safeViews.js";
 import { getTasksDir } from "../../config.js";
-import { augmentTaskWithStale, classifyStaleTask, fileMtimeIso, isValidTaskId, parseReviewVerdict, readWatcherStatusSafe, } from "../runtime.js";
-import { config, errorMessage, readJsonFileSafe, readTextFileSafe, sendJson } from "../shared.js";
+import { augmentTaskWithStale, classifyStaleTask, fileMtimeIso, isValidTaskId, parseReviewVerdict, reconstructTaskEntry, readWatcherStatusSafe, } from "../runtime.js";
+import { config, errorMessage, guardControlPath, readJsonFileSafe, readTextFileSafe, sendJson } from "../shared.js";
 export function handleTasks(res, filters) {
     try {
         const result = listTasks({ limit: 100 });
         const watcher = result.watcher;
         const now = Date.now();
         let augmented = result.tasks.map((t) => augmentTaskWithStale(t, watcher, now));
+        const facetSource = augmented.slice();
         // Apply optional filters from query params.
         if (filters) {
             if (filters.repo_path) {
@@ -46,23 +47,59 @@ export function handleTasks(res, filters) {
             }
             if (filters.warning_type) {
                 const wt = filters.warning_type;
-                if (wt === "stale") {
+                if (wt === "stale" || wt === "stale_task") {
                     augmented = augmented.filter((t) => t.is_stale);
                 }
                 else if (wt === "error") {
                     augmented = augmented.filter((t) => t.error !== null && t.error !== "");
                 }
+                else if (wt === "failed_verification") {
+                    augmented = augmented.filter((t) => t.status === wt);
+                }
                 else {
-                    // Treat as a specific stale_reason token to match against.
-                    augmented = augmented.filter((t) => Array.isArray(t.stale_reasons) && t.stale_reasons.includes(wt));
+                    augmented = augmented.filter((t) => t.status === wt || t.acceptance_status === wt ||
+                        (Array.isArray(t.stale_reasons) && t.stale_reasons.includes(wt)));
                 }
             }
+            if (filters.date_from || filters.date_to) {
+                const from = filters.date_from ? Date.parse(`${filters.date_from}T00:00:00`) : Number.NEGATIVE_INFINITY;
+                const to = filters.date_to ? Date.parse(`${filters.date_to}T23:59:59`) : Number.POSITIVE_INFINITY;
+                augmented = augmented.filter((task) => {
+                    const timestamp = Date.parse(String(task.updated_at || task.created_at || ""));
+                    return Number.isFinite(timestamp) && timestamp >= from && timestamp <= to;
+                });
+            }
         }
+        augmented.sort((a, b) => String(b.created_at || "").localeCompare(String(a.created_at || "")) || String(b.task_id).localeCompare(String(a.task_id)));
         const staleCount = augmented.filter((t) => t.is_stale).length;
+        const limit = Math.max(10, Math.min(filters?.limit || 25, 100));
+        const offset = filters?.cursor && /^\d+$/.test(filters.cursor) ? Number(filters.cursor) : 0;
+        const page = augmented.slice(offset, offset + limit);
+        const nextCursor = offset + page.length < augmented.length ? String(offset + page.length) : null;
+        const facets = {
+            repos: [...new Set(facetSource.map((task) => String(task.repo_path || ".")))].sort(),
+            statuses: [...new Set(facetSource.map((task) => String(task.status || "unknown")))].sort(),
+            agents: [...new Set(facetSource.map((task) => String(task.agent || "unknown")))].sort(),
+        };
         sendJson(res, 200, {
-            tasks: augmented,
+            tasks: page,
             total: augmented.length,
-            returned: augmented.length,
+            returned: page.length,
+            nextCursor,
+            next_cursor: nextCursor,
+            filters: {
+                applied: {
+                    repo_path: filters?.repo_path || null,
+                    status: filters?.status || null,
+                    acceptance_status: filters?.acceptance_status || null,
+                    agent: filters?.agent || null,
+                    warning_type: filters?.warning_type || null,
+                    date_from: filters?.date_from || null,
+                    date_to: filters?.date_to || null,
+                },
+                options: facets,
+            },
+            facets,
             watcher,
             stale_count: staleCount,
         });
@@ -72,6 +109,10 @@ export function handleTasks(res, filters) {
             tasks: [],
             total: 0,
             returned: 0,
+            nextCursor: null,
+            next_cursor: null,
+            filters: { applied: {}, options: { repos: [], statuses: [], agents: [] } },
+            facets: { repos: [], statuses: [], agents: [] },
             watcher: null,
             stale_count: 0,
             error: errorMessage(err),
@@ -140,9 +181,13 @@ export function handleStaleTasks(res) {
 }
 export function handleTaskDetail(res, taskId) {
     try {
+        if (!isValidTaskId(taskId)) {
+            sendJson(res, 400, { error: "Invalid task id" });
+            return;
+        }
         const tasksDir = getTasksDir(config);
-        const taskDir = join(tasksDir, taskId);
-        if (!existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
+        const taskDir = guardControlPath(join(tasksDir, taskId), config.tasksDir);
+        if (!taskDir || !existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
             sendJson(res, 404, { error: "Task not found" });
             return;
         }
@@ -187,33 +232,7 @@ export function handleTaskDetail(res, taskId) {
         let stale = null;
         if (statusData) {
             const watcher = readWatcherStatusSafe();
-            const VALID_ACCEPTANCE2 = ["pending", "accepted", "rejected", "needs_fix", "blocked"];
-            const taskStatus2 = String(statusData.status || "pending");
-            const taskAcceptanceStatus2 = taskStatus2 === "done_by_agent"
-                ? (typeof statusData.acceptance_status === "string" && VALID_ACCEPTANCE2.includes(statusData.acceptance_status) ? statusData.acceptance_status : "pending")
-                : null;
-            const entry = {
-                task_id: taskId,
-                plan_id: String(statusData.plan_id || ""),
-                title: "",
-                agent: String(statusData.agent || ""),
-                status: taskStatus2,
-                phase: String(runtimeData?.phase || statusData.phase || "queued"),
-                acceptance_status: taskAcceptanceStatus2,
-                created_at: String(statusData.created_at || ""),
-                updated_at: String(statusData.updated_at || ""),
-                workspace_root: String(statusData.workspace_root || config.workspaceRoot),
-                repo_path: String(statusData.repo_path || "."),
-                resolved_repo_path: String(statusData.resolved_repo_path || statusData.repo_path || config.workspaceRoot),
-                test_command: String(statusData.test_command || ""),
-                verify_commands: Array.isArray(statusData.verify_commands) ? statusData.verify_commands : [],
-                error: statusData.error ? String(statusData.error) : null,
-                last_heartbeat_at: String(runtimeData?.last_heartbeat_at || statusData.last_heartbeat_at || statusData.updated_at || ""),
-                current_command: runtimeData?.current_command === undefined ? null : String(runtimeData.current_command || "") || null,
-                timeout_seconds: Number(statusData.timeout_seconds) || config.defaultTaskTimeoutSeconds,
-                pending_reason: null,
-                watcher_status: watcher.status,
-            };
+            const entry = reconstructTaskEntry(taskId, statusData, runtimeData ?? {}, watcher);
             stale = classifyStaleTask(entry, watcher);
         }
         sendJson(res, 200, {
@@ -246,12 +265,7 @@ export function handleTaskSafeResult(res, taskId) {
             sendJson(res, 400, { error: "Invalid task id" });
             return;
         }
-        try {
-            sendJson(res, 200, safeResult(taskId, { max_items: 12 }));
-        }
-        catch (err) {
-            sendJson(res, 200, { task_id: taskId, error: errorMessage(err) });
-        }
+        sendJson(res, 200, safeResult(taskId, { max_items: 12 }));
     }
     catch (err) {
         sendJson(res, 200, { task_id: taskId, error: errorMessage(err) });
@@ -263,12 +277,7 @@ export function handleTaskSafeAudit(res, taskId) {
             sendJson(res, 400, { error: "Invalid task id" });
             return;
         }
-        try {
-            sendJson(res, 200, safeAudit(taskId, { max_items: 12 }));
-        }
-        catch (err) {
-            sendJson(res, 200, { task_id: taskId, error: errorMessage(err) });
-        }
+        sendJson(res, 200, safeAudit(taskId, { max_items: 12 }));
     }
     catch (err) {
         sendJson(res, 200, { task_id: taskId, error: errorMessage(err) });
@@ -280,12 +289,7 @@ export function handleTaskSafeTestSummary(res, taskId) {
             sendJson(res, 400, { error: "Invalid task id" });
             return;
         }
-        try {
-            sendJson(res, 200, safeTestSummary(taskId));
-        }
-        catch (err) {
-            sendJson(res, 200, { task_id: taskId, error: errorMessage(err) });
-        }
+        sendJson(res, 200, safeTestSummary(taskId));
     }
     catch (err) {
         sendJson(res, 200, { task_id: taskId, error: errorMessage(err) });
@@ -297,12 +301,7 @@ export function handleTaskSafeDiffSummary(res, taskId) {
             sendJson(res, 400, { error: "Invalid task id" });
             return;
         }
-        try {
-            sendJson(res, 200, safeDiffSummary(taskId, { max_items: 12 }));
-        }
-        catch (err) {
-            sendJson(res, 200, { task_id: taskId, error: errorMessage(err) });
-        }
+        sendJson(res, 200, safeDiffSummary(taskId, { max_items: 12 }));
     }
     catch (err) {
         sendJson(res, 200, { task_id: taskId, error: errorMessage(err) });