patchwarden 1.5.0 → 1.6.1

package/dist/control/routes/sessions.js

@@ -0,0 +1,287 @@
+/**
+ * Control Center routes — Direct sessions (/api/direct-sessions/*).
+ *
+ * Lists, inspects, finalizes, audits, and hides Direct editing sessions. The
+ * list/detail endpoints are read-only and fault-tolerant (missing dir returns
+ * an empty list, never 500). The finalize/audit/hide endpoints are POST routes
+ * gated by the control token in the server router.
+ */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getDirectSessionsDir } from "../../config.js";
+import { safeAuditDirectSession, safeDirectSummary, safeFinalizeDirectSession } from "../../tools/diagnostics/safeViews.js";
+import { fileMtimeIso, isValidDirectSessionId, readHiddenDirectSessionIds, recordEvent, writeHiddenDirectSessionIds, } from "../runtime.js";
+import { config, errorMessage, guardControlPath, readJsonFileSafe, readTextFileSafe, sendJson } from "../shared.js";
+function readDirectSessionSummary(sessionDir, sessionId) {
+    const sessionFile = join(sessionDir, "session.json");
+    if (!existsSync(sessionFile))
+        return null;
+    const data = readJsonFileSafe(sessionFile);
+    if (!data)
+        return null;
+    // summary.json holds the finalized change summary (changed_files_total, etc.)
+    const summaryFile = join(sessionDir, "summary.json");
+    const summary = readJsonFileSafe(summaryFile);
+    const changedFilesTotal = summary
+        ? typeof summary.changed_files_total === "number"
+            ? summary.changed_files_total
+            : null
+        : null;
+    // audit.json (written by audit_session) holds the audit decision
+    const auditFile = join(sessionDir, "audit.json");
+    const audit = readJsonFileSafe(auditFile);
+    const auditDecision = audit
+        ? typeof audit.decision === "string"
+            ? audit.decision
+            : typeof audit.verdict === "string"
+                ? audit.verdict
+                : null
+        : null;
+    const auditCheckedAt = audit
+        ? typeof audit.checked_at === "string"
+            ? audit.checked_at
+            : fileMtimeIso(auditFile)
+        : null;
+    // verification summary: read from session.json verification_runs (last run)
+    let verificationSummary = null;
+    if (Array.isArray(data.verification_runs) && data.verification_runs.length > 0) {
+        const runs = data.verification_runs;
+        verificationSummary = runs[runs.length - 1];
+    }
+    return {
+        session_id: sessionId,
+        repo_path: typeof data.repo_path === "string" ? data.repo_path : "",
+        resolved_repo_path: typeof data.resolved_repo_path === "string" ? data.resolved_repo_path : "",
+        created_at: typeof data.created_at === "string" ? data.created_at : "",
+        expires_at: typeof data.expires_at === "string" ? data.expires_at : "",
+        finalized: Boolean(data.finalized),
+        finalized_at: typeof data.finalized_at === "string" ? data.finalized_at : null,
+        audited: Boolean(data.audited),
+        changed_files_total: changedFilesTotal,
+        verification_summary: verificationSummary,
+        audit_decision: auditDecision,
+        audit_checked_at: auditCheckedAt,
+        title: typeof data.title === "string" ? data.title : "",
+    };
+}
+export function handleDirectSessions(res, filters) {
+    try {
+        const sessionsDir = getDirectSessionsDir(config);
+        if (!existsSync(sessionsDir)) {
+            // Directory missing -> empty list, never 500.
+            sendJson(res, 200, emptyDirectSessionResponse(filters));
+            return;
+        }
+        let entries = [];
+        try {
+            entries = readdirSync(sessionsDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+        }
+        catch (err) {
+            sendJson(res, 200, { ...emptyDirectSessionResponse(filters), reason: errorMessage(err) });
+            return;
+        }
+        // Filter out sessions hidden from the dashboard via POST .../hide.
+        const hiddenIds = new Set(readHiddenDirectSessionIds());
+        const summaries = [];
+        for (const entry of entries) {
+            if (hiddenIds.has(entry.name))
+                continue;
+            const sessionDir = guardControlPath(join(sessionsDir, entry.name), config.directSessionsDir);
+            if (!sessionDir)
+                continue;
+            const summary = readDirectSessionSummary(sessionDir, entry.name);
+            if (summary)
+                summaries.push(summary);
+        }
+        // Sort by created_at descending, then apply archive filters and pagination.
+        summaries.sort((a, b) => b.created_at.localeCompare(a.created_at));
+        const now = Date.now();
+        let filtered = summaries;
+        if (filters?.state) {
+            filtered = filtered.filter((session) => {
+                const expired = Boolean(session.expires_at) && Date.parse(session.expires_at) < now;
+                if (filters.state === "archive")
+                    return session.finalized || session.audited || expired;
+                if (filters.state === "expired")
+                    return expired;
+                if (filters.state === "audited")
+                    return session.audited && !expired;
+                if (filters.state === "finalized")
+                    return session.finalized && !session.audited && !expired;
+                return !session.finalized && !expired;
+            });
+        }
+        if (filters?.repo_path)
+            filtered = filtered.filter((session) => session.repo_path === filters.repo_path);
+        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;
+            filtered = filtered.filter((session) => {
+                const timestamp = Date.parse(session.created_at);
+                return Number.isFinite(timestamp) && timestamp >= from && timestamp <= to;
+            });
+        }
+        const limit = Math.max(10, Math.min(filters?.limit || 30, 100));
+        const offset = filters?.cursor && /^\d+$/.test(filters.cursor) ? Number(filters.cursor) : 0;
+        const sessions = filtered.slice(offset, offset + limit);
+        const nextCursor = offset + sessions.length < filtered.length ? String(offset + sessions.length) : null;
+        const repos = [...new Set(summaries.map((session) => session.repo_path).filter(Boolean))].sort();
+        sendJson(res, 200, {
+            sessions,
+            total: filtered.length,
+            returned: sessions.length,
+            nextCursor,
+            next_cursor: nextCursor,
+            filters: {
+                applied: {
+                    state: filters?.state || null,
+                    repo_path: filters?.repo_path || null,
+                    date_from: filters?.date_from || null,
+                    date_to: filters?.date_to || null,
+                },
+                options: { repos, states: ["active", "archive", "finalized", "audited", "expired"] },
+            },
+            direct_profile_enabled: config.enableDirectProfile === true,
+            reason: null,
+        });
+    }
+    catch (err) {
+        sendJson(res, 200, { ...emptyDirectSessionResponse(filters), reason: errorMessage(err) });
+    }
+}
+function emptyDirectSessionResponse(filters) {
+    return {
+        sessions: [],
+        total: 0,
+        returned: 0,
+        nextCursor: null,
+        next_cursor: null,
+        filters: {
+            applied: {
+                state: filters?.state || null,
+                repo_path: filters?.repo_path || null,
+                date_from: filters?.date_from || null,
+                date_to: filters?.date_to || null,
+            },
+            options: { repos: [], states: ["active", "archive", "finalized", "audited", "expired"] },
+        },
+        direct_profile_enabled: config.enableDirectProfile === true,
+        reason: null,
+    };
+}
+export function handleDirectSessionDetail(res, sessionId) {
+    try {
+        if (!isValidDirectSessionId(sessionId)) {
+            sendJson(res, 400, { error: "Invalid session id" });
+            return;
+        }
+        const sessionsDir = getDirectSessionsDir(config);
+        const sessionDir = guardControlPath(join(sessionsDir, sessionId), config.directSessionsDir);
+        if (!sessionDir || !existsSync(sessionDir) || !statSync(sessionDir).isDirectory()) {
+            sendJson(res, 404, { error: "Direct session not found" });
+            return;
+        }
+        const summary = readDirectSessionSummary(sessionDir, sessionId);
+        sendJson(res, 200, {
+            session_id: sessionId,
+            summary,
+            session: readJsonFileSafe(join(sessionDir, "session.json")),
+            summary_md: readTextFileSafe(join(sessionDir, "summary.md")),
+            diff_patch: readTextFileSafe(join(sessionDir, "diff.patch")),
+            audit_json: readJsonFileSafe(join(sessionDir, "audit.json")),
+            audit_md: readTextFileSafe(join(sessionDir, "audit.md")),
+            changed_files: readJsonFileSafe(join(sessionDir, "changed-files.json")),
+        });
+    }
+    catch (err) {
+        sendJson(res, 200, { session_id: sessionId, error: errorMessage(err) });
+    }
+}
+export function handleDirectSessionSafeSummary(res, sessionId) {
+    try {
+        if (!isValidDirectSessionId(sessionId)) {
+            sendJson(res, 400, { error: "Invalid session id" });
+            return;
+        }
+        sendJson(res, 200, safeDirectSummary(sessionId, { max_items: 12 }));
+    }
+    catch (err) {
+        sendJson(res, 200, {
+            session_id: sessionId,
+            error: errorMessage(err),
+            large_logs_omitted: true,
+            diff_omitted: true,
+        });
+    }
+}
+/**
+ * Finalize a direct session via safeFinalizeDirectSession. Returns the safe
+ * summary on success, or { error } on failure with HTTP 200 (fault tolerance:
+ * the UI always gets a JSON body it can render).
+ */
+export async function handleDirectSessionFinalize(res, sessionId) {
+    try {
+        if (!isValidDirectSessionId(sessionId)) {
+            sendJson(res, 400, { error: "Invalid session id" });
+            return;
+        }
+        const result = await safeFinalizeDirectSession(sessionId, { max_items: 12 });
+        recordEvent("direct_session.finalized", { session_id: sessionId });
+        sendJson(res, 200, result);
+    }
+    catch (err) {
+        sendJson(res, 200, {
+            session_id: sessionId,
+            error: errorMessage(err),
+            large_logs_omitted: true,
+            diff_omitted: true,
+        });
+    }
+}
+/**
+ * Audit a direct session via safeAuditDirectSession. Returns the safe audit
+ * result on success, or { error } on failure (HTTP 200 for fault tolerance).
+ */
+export function handleDirectSessionAudit(res, sessionId) {
+    try {
+        if (!isValidDirectSessionId(sessionId)) {
+            sendJson(res, 400, { error: "Invalid session id" });
+            return;
+        }
+        const result = safeAuditDirectSession(sessionId, { max_items: 12 });
+        recordEvent("direct_session.audited", { session_id: sessionId });
+        sendJson(res, 200, result);
+    }
+    catch (err) {
+        sendJson(res, 200, {
+            session_id: sessionId,
+            error: errorMessage(err),
+            large_logs_omitted: true,
+            diff_omitted: true,
+        });
+    }
+}
+/**
+ * Hide a direct session from the dashboard list. The session itself is NOT
+ * deleted or modified — only the control-center's local
+ * hidden-direct-session-ids.json state file is updated. Requires control token
+ * (enforced by the POST router).
+ */
+export function handleDirectSessionHide(res, sessionId) {
+    try {
+        if (!isValidDirectSessionId(sessionId)) {
+            sendJson(res, 400, { error: "Invalid session id" });
+            return;
+        }
+        const ids = readHiddenDirectSessionIds();
+        if (!ids.includes(sessionId)) {
+            ids.push(sessionId);
+            writeHiddenDirectSessionIds(ids);
+        }
+        recordEvent("direct_session.hidden", { session_id: sessionId });
+        sendJson(res, 200, { ok: true, hidden: sessionId });
+    }
+    catch (err) {
+        sendJson(res, 500, { error: errorMessage(err) });
+    }
+}

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

@@ -0,0 +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): Promise<void>;
+export {};

package/dist/control/routes/status.js

@@ -0,0 +1,307 @@
+/**
+ * Control Center routes — runtime status, events, diagnostics, tunnel URLs.
+ *
+ * `handleStatus` is the dashboard's primary poll endpoint: it fans out health
+ * probes, watcher/task snapshots, and suggestion generation, and records
+ * observed state-change events (core/direct/watcher/task transitions) into the
+ * activity timeline. The remaining endpoints expose the control-center status
+ * file, the event timeline, diagnostics (redacted), and tunnel UI URLs.
+ */
+import { existsSync } from "node:fs";
+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, 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({
+            code: "core_stopped",
+            severity: "warning",
+            message: "Core 未运行，建议启动 Core profile",
+            action: "/api/core/start",
+        });
+    }
+    if (s.direct_profile_enabled && !s.direct.available) {
+        out.push({
+            code: "direct_stopped",
+            severity: "warning",
+            message: "Direct 未运行，建议启动 Direct profile",
+            action: "/api/direct/start",
+        });
+    }
+    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 + " 状态，建议重启 Core",
+            action: "/api/core/restart",
+        });
+    }
+    if (s.tasks.stale > 0) {
+        out.push({
+            code: "stale_task",
+            severity: "warning",
+            message: "存在 " + s.tasks.stale + " 个 stale 任务，建议查看并 reconcile",
+            link: "/pages/tasks.html?filter=stale",
+        });
+    }
+    const coreTunnelReady = !!(s.tunnel.core && s.tunnel.core.ready);
+    const directTunnelReady = !!(s.tunnel.direct && s.tunnel.direct.ready);
+    if (!coreTunnelReady || (s.direct_profile_enabled && !directTunnelReady)) {
+        out.push({
+            code: "tunnel_not_ready",
+            severity: "warning",
+            message: "Tunnel 未就绪，建议启动 profile 或检查代理",
+            action: "/api/start-all",
+        });
+    }
+    const missingAgents = s.agents.filter((a) => !a.available);
+    if (missingAgents.length > 0) {
+        out.push({
+            code: "agent_missing",
+            severity: "info",
+            message: "Agent 未就绪：" + missingAgents.map((a) => a.name).join(", ") + "（请检查对应 CLI 安装与路径）",
+        });
+    }
+    return out;
+}
+let lastStatusDigest = null;
+function buildStatusDigest(s) {
+    const task_statuses = {};
+    for (const t of s.tasks.tasks) {
+        const entry = t;
+        task_statuses[entry.task_id] = entry.status;
+    }
+    return {
+        core_available: s.core.available,
+        direct_available: s.direct.available,
+        watcher_status: s.watcher.status,
+        task_statuses,
+    };
+}
+function diffAndRecordEvents(prev, curr) {
+    if (prev.core_available !== curr.core_available) {
+        recordEvent("core.status_changed", { from: prev.core_available, to: curr.core_available });
+    }
+    if (prev.direct_available !== curr.direct_available) {
+        recordEvent("direct.status_changed", { from: prev.direct_available, to: curr.direct_available });
+    }
+    if (prev.watcher_status !== curr.watcher_status) {
+        recordEvent("watcher.status_changed", { from: prev.watcher_status, to: curr.watcher_status });
+    }
+    for (const [taskId, newStatus] of Object.entries(curr.task_statuses)) {
+        const oldStatus = prev.task_statuses[taskId];
+        if (oldStatus && oldStatus !== newStatus) {
+            recordEvent("task.status_changed", { task_id: taskId, from: oldStatus, to: newStatus });
+        }
+    }
+}
+// ── Handlers ──────────────────────────────────────────────────────
+export async function handleStatus(res) {
+    try {
+        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),
+                healthz: null,
+                readyz: null,
+            })),
+            probeRuntimeHealth(DIRECT_BASE_URL).catch((err) => ({
+                available: false,
+                reason: errorMessage(err),
+                healthz: null,
+                readyz: null,
+            })),
+            Promise.resolve(readWatcherStatusSafe()),
+            Promise.resolve(readTunnelStatus(false)),
+            Promise.resolve(readTunnelStatus(true)),
+            Promise.resolve(readToolManifest(false)),
+            Promise.resolve(readToolManifest(true)),
+            Promise.resolve(listAgentsSafe()),
+            Promise.resolve(resolveWorkspaceRootSafe()),
+            Promise.resolve(listTasksForStatus()),
+        ]);
+        const tunnelCore = reconcileTunnelStatus(tunnelCoreRaw, coreHealth);
+        const tunnelDirect = reconcileTunnelStatus(tunnelDirectRaw, directHealth);
+        const snapshotForSuggestions = {
+            core: coreHealth,
+            direct: directHealth,
+            watcher,
+            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
+        // (the control center is otherwise stateless and pull-driven).
+        const digest = buildStatusDigest(snapshotForSuggestions);
+        if (lastStatusDigest) {
+            diffAndRecordEvents(lastStatusDigest, digest);
+        }
+        lastStatusDigest = digest;
+        sendJson(res, 200, {
+            core: coreHealth,
+            direct: directHealth,
+            watcher,
+            tunnel: { core: tunnelCore, direct: tunnelDirect },
+            tools: { core: toolsCore, direct: toolsDirect },
+            agents,
+            workspace_root: workspaceRoot,
+            tasks,
+            suggestions,
+            experience,
+            direct_profile_enabled: config.enableDirectProfile === true,
+            setup: {
+                tunnel_client: {
+                    available: tunnelClientExe !== null,
+                    path: tunnelClientExe,
+                    source: config.tunnelClientPath && tunnelClientExe === config.tunnelClientPath ? "config" : "detected",
+                },
+                workspace_root: workspaceRoot,
+                watcher: {
+                    status: watcher.status,
+                    available: watcher.available,
+                    reason: watcher.reason,
+                },
+            },
+        });
+    }
+    catch (err) {
+        sendJson(res, 200, { error: errorMessage(err), partial: true });
+    }
+}
+export function handleControlCenterStatus(res) {
+    // Public read of the status file (used by tray/launcher to confirm identity).
+    if (!existsSync(controlCenterStatusPath)) {
+        sendJson(res, 200, { running: false });
+        return;
+    }
+    const data = readJsonFileSafe(controlCenterStatusPath);
+    if (!data) {
+        sendJson(res, 200, { running: false });
+        return;
+    }
+    sendJson(res, 200, { running: true, ...data });
+}
+export function handleEvents(res, limit) {
+    const events = readEvents(limit);
+    sendJson(res, 200, {
+        events,
+        total: events.length,
+        limit,
+    });
+}
+export function handleTunnelUiUrl(res) {
+    sendJson(res, 200, {
+        core: readTunnelUrl(false),
+        direct: readTunnelUrl(true),
+    });
+}
+export async function handleDiagnostics(res) {
+    try {
+        const watcher = readWatcherStatusSafe();
+        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();
+        let workspaceRoot = null;
+        try {
+            workspaceRoot = resolveWorkspaceRootSafe();
+        }
+        catch {
+            workspaceRoot = null;
+        }
+        // Recent failures: last 5 failed tasks (status contains "failed")
+        let recentFailures = [];
+        try {
+            const result = listTasksForStatus();
+            recentFailures = result.tasks
+                .filter((t) => typeof t.status === "string" && t.status.includes("failed"))
+                .slice(0, 5)
+                .map((t) => ({ task_id: t.task_id, status: t.status }));
+        }
+        catch {
+            recentFailures = [];
+        }
+        const coreReady = !!(tunnelCore && tunnelCore.ready);
+        const directReady = !!(tunnelDirect && tunnelDirect.ready);
+        const diagnostics = {
+            server_version: PATCHWARDEN_VERSION,
+            schema_epoch: TOOL_SCHEMA_EPOCH,
+            tool_manifest_sha256: toolsCore.tool_manifest_sha256,
+            watcher_status: watcher.status,
+            tunnel_core_ready: coreReady,
+            tunnel_direct_ready: directReady,
+            core_tool_count: toolsCore.tool_count,
+            direct_tool_count: toolsDirect.tool_count,
+            agent_status: agents.map((a) => ({ name: a.name, available: a.available })),
+            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);
+        sendJson(res, 200, redacted.value);
+    }
+    catch (err) {
+        sendJson(res, 200, { error: errorMessage(err) });
+    }
+}

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

@@ -0,0 +1,21 @@
+import { type ServerResponse } from "node:http";
+/**
+ * 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
+ * reconcile record, and (when safe) annotates status.json with reconcile
+ * metadata. The task status enum is never changed — only metadata is added.
+ */
+export declare function handleReconcile(res: ServerResponse, taskId: string): void;
+/**
+ * Run audit_task for a task. Only safe to delegate when the task directory
+ * exists and the task is in a terminal state (auditing a running task mid-flight
+ * would race with the watcher writing artifacts).
+ */
+export declare function handleTaskAudit(res: ServerResponse, taskId: string): void;
+export declare function handleOpenTaskFolder(res: ServerResponse, taskId: string): void;
+/**
+ * Hide a stale task from the dashboard's stale-task view. The task itself is
+ * NOT deleted or modified — only the control-center's local hidden-stale-ids
+ * state file is updated. Requires control token (enforced by the POST router).
+ */
+export declare function handleHideStale(res: ServerResponse, taskId: string): void;