patchwarden 0.4.0 → 0.6.1

package/dist/tools/searchWorkspace.d.ts

@@ -0,0 +1,19 @@
+export interface SearchWorkspaceInput {
+    session_id: string;
+    query: string;
+    max_results?: number;
+    case_sensitive?: boolean;
+    max_preview_chars?: number;
+    include_globs?: string[];
+}
+export interface SearchMatch {
+    path: string;
+    line: number;
+    preview: string;
+}
+export interface SearchWorkspaceOutput {
+    results: SearchMatch[];
+    total_matches: number;
+    truncated: boolean;
+}
+export declare function searchWorkspace(input: SearchWorkspaceInput): SearchWorkspaceOutput;

package/dist/tools/searchWorkspace.js

@@ -0,0 +1,205 @@
+import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
+import { relative, join, extname } from "node:path";
+import { getConfig } from "../config.js";
+import { PatchWardenError } from "../errors.js";
+import { isSensitivePath } from "../security/sensitiveGuard.js";
+import { validateDirectSessionFreshness, } from "../direct/directSessionStore.js";
+import { guardDirectSessionActive } from "../direct/directGuards.js";
+// ── Constants ──────────────────────────────────────────────────────
+const SKIP_DIRECTORIES = new Set([
+    ".git",
+    ".patchwarden",
+    "node_modules",
+    "dist",
+    "release",
+    "coverage",
+    ".next",
+    ".turbo",
+]);
+const BINARY_EXTENSIONS = new Set([
+    ".exe",
+    ".dll",
+    ".so",
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".bmp",
+    ".ico",
+    ".webp",
+    ".pdf",
+    ".mp3",
+    ".mp4",
+    ".zip",
+    ".gz",
+    ".tar",
+    ".bin",
+    ".dat",
+    ".class",
+    ".jar",
+    ".wasm",
+    ".node",
+]);
+// Safety valve: stop scanning after this many total matches to prevent
+// runaway searches in large repositories with very common terms.
+const MAX_TOTAL_MATCHES = 10_000;
+// ── Tool implementation ────────────────────────────────────────────
+export function searchWorkspace(input) {
+    const config = getConfig();
+    // ── Validate session freshness ───────────────────────────────────
+    const validation = validateDirectSessionFreshness(input.session_id);
+    if (!validation.valid || !validation.session) {
+        throw new PatchWardenError(validation.failure_reason || "session_invalid", `Direct session "${input.session_id}" is not valid: ${validation.failure_reason}.`, "Create a new direct session with create_direct_session.", true, {
+            session_id: input.session_id,
+            failure_reason: validation.failure_reason,
+            operation: "search_workspace",
+        });
+    }
+    const session = validation.session;
+    guardDirectSessionActive(session);
+    // ── Validate query ───────────────────────────────────────────────
+    if (!input.query || input.query.trim() === "") {
+        throw new PatchWardenError("invalid_input", "query is required and must be a non-empty string.", "Provide a search query to look for in file contents.", true, { operation: "search_workspace", session_id: input.session_id });
+    }
+    // ── Resolve parameters ───────────────────────────────────────────
+    const maxResults = input.max_results ?? 20;
+    const caseSensitive = input.case_sensitive ?? false;
+    const maxPreviewChars = input.max_preview_chars ?? 200;
+    const includeGlobs = input.include_globs;
+    const query = caseSensitive ? input.query : input.query.toLowerCase();
+    const repoPath = session.resolved_repo_path;
+    if (!existsSync(repoPath)) {
+        throw new PatchWardenError("repo_not_found", `Session repo path "${repoPath}" no longer exists.`, "Create a new direct session with create_direct_session.", true, {
+            session_id: input.session_id,
+            resolved_repo_path: repoPath,
+            operation: "search_workspace",
+        });
+    }
+    // ── Recursive search ─────────────────────────────────────────────
+    const results = [];
+    let totalMatches = 0;
+    let truncated = false;
+    const visit = (directory) => {
+        if (truncated && totalMatches >= MAX_TOTAL_MATCHES)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (totalMatches >= MAX_TOTAL_MATCHES) {
+                truncated = true;
+                return;
+            }
+            // Skip blacklisted directories
+            if (entry.isDirectory() && SKIP_DIRECTORIES.has(entry.name)) {
+                continue;
+            }
+            const fullPath = join(directory, entry.name);
+            const relPath = relative(repoPath, fullPath).replace(/\\/g, "/");
+            if (entry.isDirectory()) {
+                visit(fullPath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            // Skip sensitive files
+            if (isSensitivePath(relPath))
+                continue;
+            // Skip binary files by extension
+            const ext = extname(entry.name).toLowerCase();
+            if (BINARY_EXTENSIONS.has(ext))
+                continue;
+            // Apply include_globs filter
+            if (includeGlobs && includeGlobs.length > 0) {
+                if (!matchesAnyGlob(relPath, includeGlobs))
+                    continue;
+            }
+            // Read file content and search line by line
+            let content;
+            try {
+                const fileStat = statSync(fullPath);
+                if (fileStat.size > config.directMaxFileBytes)
+                    continue;
+                content = readFileSync(fullPath, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const lines = content.split(/\r?\n/);
+            for (let i = 0; i < lines.length; i++) {
+                if (totalMatches >= MAX_TOTAL_MATCHES) {
+                    truncated = true;
+                    break;
+                }
+                const line = lines[i];
+                const haystack = caseSensitive ? line : line.toLowerCase();
+                if (haystack.includes(query)) {
+                    totalMatches++;
+                    if (results.length < maxResults) {
+                        const preview = line.length > maxPreviewChars
+                            ? line.slice(0, maxPreviewChars)
+                            : line;
+                        results.push({
+                            path: relPath,
+                            line: i + 1,
+                            preview,
+                        });
+                    }
+                    else {
+                        truncated = true;
+                    }
+                }
+            }
+        }
+    };
+    visit(repoPath);
+    return {
+        results,
+        total_matches: totalMatches,
+        truncated,
+    };
+}
+// ── Glob matching ──────────────────────────────────────────────────
+function matchesAnyGlob(filePath, globs) {
+    for (const pattern of globs) {
+        if (matchGlob(filePath, pattern))
+            return true;
+    }
+    return false;
+}
+/**
+ * Simple glob matching: "*" matches any sequence of characters (including
+ * path separators), "?" matches a single character.
+ *
+ * Examples:
+ *   "*.ts"       matches "foo.ts", "src/bar.ts"
+ *   "src/*.ts"   matches "src/foo.ts", "src/sub/bar.ts"
+ *   "*.test.ts"  matches "foo.test.ts", "src/bar.test.ts"
+ */
+function matchGlob(filePath, pattern) {
+    const normalizedPattern = pattern.replace(/\\/g, "/");
+    const regex = globToRegex(normalizedPattern);
+    return regex.test(filePath);
+}
+function globToRegex(pattern) {
+    let regexStr = "";
+    for (const char of pattern) {
+        if (char === "*") {
+            regexStr += ".*";
+        }
+        else if (char === "?") {
+            regexStr += ".";
+        }
+        else if (/[.+^${}()|[\]\\]/.test(char)) {
+            regexStr += "\\" + char;
+        }
+        else {
+            regexStr += char;
+        }
+    }
+    return new RegExp("^" + regexStr + "$");
+}

package/dist/tools/syncFile.d.ts

@@ -0,0 +1,18 @@
+import { type PatchWardenConfig } from "../config.js";
+export interface SyncFileResult {
+    source_path: string;
+    target_path: string;
+    before_target_sha256: string | null;
+    after_target_sha256: string;
+    source_sha256: string;
+    copied_bytes: number;
+    changed: boolean;
+}
+/**
+ * Copy a file from source to target within the same session repo.
+ * Both source and target must be inside the session's repo_path.
+ */
+export declare function syncFile(sessionId: string, sourcePath: string, targetPath: string, options?: {
+    expected_source_sha256?: string;
+    expected_target_sha256?: string;
+}, config?: PatchWardenConfig): SyncFileResult;

package/dist/tools/syncFile.js

@@ -0,0 +1,65 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { PatchWardenError } from "../errors.js";
+import { getConfig } from "../config.js";
+import { guardDirectPath, guardDirectWritePath } from "../direct/directGuards.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+import { computeFileSha256 } from "../direct/directPatch.js";
+/**
+ * Copy a file from source to target within the same session repo.
+ * Both source and target must be inside the session's repo_path.
+ */
+export function syncFile(sessionId, sourcePath, targetPath, options, config) {
+    const cfg = config || getConfig();
+    const sessionsDir = resolve(cfg.workspaceRoot, cfg.directSessionsDir);
+    // Load session to get repo_path
+    const sessionFile = resolve(sessionsDir, sessionId, "session.json");
+    if (!existsSync(sessionFile)) {
+        throw new PatchWardenError("direct_session_not_found", `Direct session "${sessionId}" not found.`, "Create a direct session first using direct_start_session.", true, { session_id: sessionId });
+    }
+    const session = JSON.parse(readFileSync(sessionFile, "utf-8"));
+    const repoPath = resolve(session.repo_path);
+    const workspaceRoot = cfg.workspaceRoot;
+    // Guard source path — must be inside repo
+    const resolvedSource = guardDirectPath(sourcePath, repoPath, workspaceRoot);
+    guardSensitivePath(resolvedSource);
+    if (!existsSync(resolvedSource)) {
+        throw new PatchWardenError("source_file_not_found", `Source file does not exist: "${sourcePath}".`, "Ensure the source path is correct.", true, { source_path: sourcePath });
+    }
+    // Guard target path — must be inside repo, not in blocked dirs
+    const resolvedTarget = guardDirectWritePath(targetPath, repoPath, workspaceRoot);
+    guardSensitivePath(resolvedTarget);
+    // Verify source sha256 if provided
+    const sourceSha256 = computeFileSha256(resolvedSource);
+    if (options?.expected_source_sha256 && options.expected_source_sha256 !== sourceSha256) {
+        throw new PatchWardenError("source_hash_mismatch", `Source file hash mismatch. Expected "${options.expected_source_sha256}" but got "${sourceSha256}".`, "Re-read the source file to get the current sha256.", true, { expected_sha256: options.expected_source_sha256, actual_sha256: sourceSha256 });
+    }
+    // Get target sha256 before copy
+    let beforeTargetSha256 = null;
+    if (existsSync(resolvedTarget)) {
+        beforeTargetSha256 = computeFileSha256(resolvedTarget);
+        // Verify target sha256 if provided
+        if (options?.expected_target_sha256 && options.expected_target_sha256 !== beforeTargetSha256) {
+            throw new PatchWardenError("target_hash_mismatch", `Target file hash mismatch. Expected "${options.expected_target_sha256}" but got "${beforeTargetSha256}".`, "Re-read the target file to get the current sha256.", true, { expected_sha256: options.expected_target_sha256, actual_sha256: beforeTargetSha256 });
+        }
+    }
+    // Read source content
+    const sourceContent = readFileSync(resolvedSource);
+    const copiedBytes = sourceContent.length;
+    // Create target directory if needed
+    mkdirSync(dirname(resolvedTarget), { recursive: true });
+    // Write to target
+    writeFileSync(resolvedTarget, sourceContent, "utf-8");
+    // Compute after hash
+    const afterTargetSha256 = computeFileSha256(resolvedTarget);
+    const changed = beforeTargetSha256 !== afterTargetSha256;
+    return {
+        source_path: sourcePath,
+        target_path: targetPath,
+        before_target_sha256: beforeTargetSha256,
+        after_target_sha256: afterTargetSha256,
+        source_sha256: sourceSha256,
+        copied_bytes: copiedBytes,
+        changed,
+    };
+}

package/dist/tools/taskOutputs.d.ts

@@ -14,7 +14,7 @@ export declare function getTaskLogTail(taskId: string, file: "stdout" | "stderr"
     lines?: number;
     redact?: boolean;
 }): {
-    file: "stdout" | "stderr" | "test" | "verify";
+    file: "test" | "stdout" | "stderr" | "verify";
     lines: number;
     total_bytes: number;
     task_id: string;
@@ -37,7 +37,7 @@ export declare function getTaskLogTail(taskId: string, file: "stdout" | "stderr"
     truncated?: undefined;
 } | {
     task_id: string;
-    file: "stdout" | "stderr" | "test" | "verify";
+    file: "test" | "stdout" | "stderr" | "verify";
     filename: string;
     content: string;
     available: boolean;

package/dist/tools/taskTemplates.js

@@ -19,7 +19,8 @@ export function expandTaskTemplate(input) {
         `## Goal\n${goal}`,
         "## Safety boundaries",
         "- Work only inside the resolved repository path.",
-        "- Do not commit, push, publish, expose credentials, or modify unrelated files.",
+        "- Leave repository changes uncommitted for review; remote operations are outside this task.",
+        "- Keep credentials private and do not modify unrelated files.",
         "- Report exact files inspected or changed and any remaining uncertainty.",
     ];
     switch (input.template) {

package/dist/tools/toolCatalog.d.ts

@@ -1,4 +1,4 @@
-export type ToolProfile = "full" | "chatgpt_core";
+export type ToolProfile = "full" | "chatgpt_core" | "chatgpt_direct";
 export interface CatalogTool {
     name: string;
     description: string;
@@ -12,8 +12,9 @@ export interface ToolCatalogSnapshot {
     tool_names: string[];
     tool_manifest_sha256: string;
 }
-export declare const CHATGPT_CORE_TOOL_NAMES: readonly ["health_check", "list_agents", "list_workspace", "read_workspace_file", "save_plan", "create_task", "wait_for_task", "get_task_summary", "get_diff", "get_result", "get_result_json", "get_test_log", "get_task_status", "list_tasks", "cancel_task", "audit_task"];
+export declare const CHATGPT_CORE_TOOL_NAMES: readonly ["health_check", "list_agents", "list_workspace", "read_workspace_file", "save_plan", "create_task", "wait_for_task", "get_task_summary", "get_diff", "get_result", "get_result_json", "get_test_log", "get_task_status", "list_tasks", "cancel_task", "audit_task", "safe_status"];
+export declare const CHATGPT_DIRECT_TOOL_NAMES: readonly ["health_check", "list_workspace", "create_direct_session", "search_workspace", "read_workspace_file", "apply_patch", "run_verification", "finalize_direct_session", "audit_session", "sync_file"];
 export declare function resolveToolProfile(configProfile?: string): ToolProfile;
-export declare function selectToolsForProfile<T extends CatalogTool>(tools: T[], profile: ToolProfile): T[];
+export declare function selectToolsForProfile<T extends CatalogTool>(tools: T[], profile: ToolProfile, enableDirectProfile?: boolean): T[];
 export declare function buildToolCatalogSnapshot(tools: CatalogTool[], profile: ToolProfile): ToolCatalogSnapshot;
 export declare function getLastToolCatalogSnapshot(): ToolCatalogSnapshot | null;

package/dist/tools/toolCatalog.js

@@ -17,23 +17,52 @@ export const CHATGPT_CORE_TOOL_NAMES = [
     "list_tasks",
     "cancel_task",
     "audit_task",
+    "safe_status",
+];
+export const CHATGPT_DIRECT_TOOL_NAMES = [
+    "health_check",
+    "list_workspace",
+    "create_direct_session",
+    "search_workspace",
+    "read_workspace_file",
+    "apply_patch",
+    "run_verification",
+    "finalize_direct_session",
+    "audit_session",
+    "sync_file",
 ];
 let lastSnapshot = null;
 export function resolveToolProfile(configProfile) {
     const raw = (process.env.PATCHWARDEN_TOOL_PROFILE || configProfile || "full").trim();
-    if (raw !== "full" && raw !== "chatgpt_core") {
-        throw new Error(`Invalid tool profile "${raw}". Expected "full" or "chatgpt_core".`);
+    if (raw !== "full" && raw !== "chatgpt_core" && raw !== "chatgpt_direct") {
+        throw new Error(`Invalid tool profile "${raw}". Expected "full", "chatgpt_core", or "chatgpt_direct".`);
     }
     return raw;
 }
-export function selectToolsForProfile(tools, profile) {
+export function selectToolsForProfile(tools, profile, enableDirectProfile) {
     if (profile === "full")
         return tools;
     const byName = new Map(tools.map((tool) => [tool.name, tool]));
-    return CHATGPT_CORE_TOOL_NAMES.map((name) => {
+    if (profile === "chatgpt_core") {
+        return CHATGPT_CORE_TOOL_NAMES.map((name) => {
+            const tool = byName.get(name);
+            if (!tool)
+                throw new Error(`chatgpt_core tool profile requires missing tool "${name}".`);
+            return tool;
+        });
+    }
+    // chatgpt_direct
+    if (!enableDirectProfile) {
+        // Degraded mode: only expose health_check for diagnostics
+        const tool = byName.get("health_check");
+        if (!tool)
+            throw new Error(`chatgpt_direct degraded mode requires missing tool "health_check".`);
+        return [tool];
+    }
+    return CHATGPT_DIRECT_TOOL_NAMES.map((name) => {
         const tool = byName.get(name);
         if (!tool)
-            throw new Error(`chatgpt_core tool profile requires missing tool "${name}".`);
+            throw new Error(`chatgpt_direct tool profile requires missing tool "${name}".`);
         return tool;
     });
 }

package/dist/tools/waitForTask.d.ts

@@ -1,4 +1,4 @@
-import { type TaskSummaryOutput } from "./getTaskSummary.js";
+import { type TaskSummaryResult } from "./getTaskSummary.js";
 export interface WaitForTaskProgressSummary {
     phase: string;
     heartbeat_at: string;
@@ -19,7 +19,7 @@ export interface WaitForTaskOutput {
         name: "wait_for_task" | "audit_task" | "health_check";
         arguments: Record<string, unknown>;
     };
-    summary?: TaskSummaryOutput;
+    summary?: TaskSummaryResult;
     progress_summary?: WaitForTaskProgressSummary;
 }
 export declare function waitForTask(taskId: string, waitSeconds?: number): Promise<WaitForTaskOutput>;

package/dist/tools/waitForTask.js

@@ -54,6 +54,6 @@ export async function waitForTask(taskId, waitSeconds = 25) {
             : executionBlocked
                 ? { name: "health_check", arguments: {} }
                 : { name: "wait_for_task", arguments: { task_id: taskId, timeout_seconds: waitSeconds } },
-        ...(terminal ? { summary: getTaskSummary(taskId) } : { progress_summary: progressSummary }),
+        ...(terminal ? { summary: getTaskSummary(taskId, { view: "compact" }) } : { progress_summary: progressSummary }),
     };
 }

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PATCHWARDEN_VERSION = "0.4.0";
-export declare const TOOL_SCHEMA_EPOCH = "2026-06-21-v3";
+export declare const PATCHWARDEN_VERSION = "0.6.1";
+export declare const TOOL_SCHEMA_EPOCH = "2026-06-24-v7";

package/dist/version.js

@@ -1,2 +1,2 @@
-export const PATCHWARDEN_VERSION = "0.4.0";
-export const TOOL_SCHEMA_EPOCH = "2026-06-21-v3";
+export const PATCHWARDEN_VERSION = "0.6.1";
+export const TOOL_SCHEMA_EPOCH = "2026-06-24-v7";

package/dist/watcherStatus.d.ts

@@ -11,6 +11,7 @@ export interface WatcherStatusSnapshot {
     instance_id: string | null;
     launcher_pid: number | null;
     reason: string | null;
+    activity: string | null;
 }
 export declare function getWatcherHeartbeatPath(config?: PatchWardenConfig): string;
 export declare function readWatcherStatus(config?: PatchWardenConfig, nowMs?: number): WatcherStatusSnapshot;

package/dist/watcherStatus.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getConfig, getTasksDir } from "./config.js";
 export function getWatcherHeartbeatPath(config = getConfig()) {
@@ -8,6 +8,22 @@ export function readWatcherStatus(config = getConfig(), nowMs = Date.now()) {
     const staleAfterSeconds = config.watcherStaleSeconds;
     const heartbeatPath = getWatcherHeartbeatPath(config);
     if (!existsSync(heartbeatPath)) {
+        // Even if watcher heartbeat is missing, check if a task is actively running
+        const taskFallback = checkRunningTaskHeartbeat(config, nowMs, staleAfterSeconds);
+        if (taskFallback) {
+            return {
+                status: "healthy",
+                available: true,
+                stale_after_seconds: staleAfterSeconds,
+                last_heartbeat_at: taskFallback.heartbeat_at,
+                heartbeat_age_seconds: taskFallback.age_seconds,
+                heartbeat_pid: null,
+                instance_id: null,
+                launcher_pid: null,
+                reason: null,
+                activity: taskFallback.activity,
+            };
+        }
         return {
             status: "missing",
             available: false,
@@ -18,6 +34,7 @@ export function readWatcherStatus(config = getConfig(), nowMs = Date.now()) {
             instance_id: null,
             launcher_pid: null,
             reason: "Watcher heartbeat has not been observed. Start or restart the PatchWarden watcher.",
+            activity: null,
         };
     }
     try {
@@ -29,16 +46,47 @@ export function readWatcherStatus(config = getConfig(), nowMs = Date.now()) {
         const ageMs = Math.max(0, nowMs - heartbeatMs);
         const ageSeconds = Math.round(ageMs / 1000);
         const healthy = ageMs < staleAfterSeconds * 1000;
+        if (healthy) {
+            return {
+                status: "healthy",
+                available: true,
+                stale_after_seconds: staleAfterSeconds,
+                last_heartbeat_at: String(data.last_heartbeat_at),
+                heartbeat_age_seconds: ageSeconds,
+                heartbeat_pid: Number.isInteger(Number(data.pid)) ? Number(data.pid) : null,
+                instance_id: typeof data.instance_id === "string" ? data.instance_id : null,
+                launcher_pid: Number.isInteger(Number(data.launcher_pid)) ? Number(data.launcher_pid) : null,
+                reason: null,
+                activity: null,
+            };
+        }
+        // Watcher heartbeat is stale — check if a task is actively running
+        const taskFallback = checkRunningTaskHeartbeat(config, nowMs, staleAfterSeconds);
+        if (taskFallback) {
+            return {
+                status: "healthy",
+                available: true,
+                stale_after_seconds: staleAfterSeconds,
+                last_heartbeat_at: taskFallback.heartbeat_at,
+                heartbeat_age_seconds: taskFallback.age_seconds,
+                heartbeat_pid: Number.isInteger(Number(data.pid)) ? Number(data.pid) : null,
+                instance_id: typeof data.instance_id === "string" ? data.instance_id : null,
+                launcher_pid: Number.isInteger(Number(data.launcher_pid)) ? Number(data.launcher_pid) : null,
+                reason: null,
+                activity: taskFallback.activity,
+            };
+        }
         return {
-            status: healthy ? "healthy" : "stale",
-            available: healthy,
+            status: "stale",
+            available: false,
             stale_after_seconds: staleAfterSeconds,
             last_heartbeat_at: String(data.last_heartbeat_at),
             heartbeat_age_seconds: ageSeconds,
             heartbeat_pid: Number.isInteger(Number(data.pid)) ? Number(data.pid) : null,
             instance_id: typeof data.instance_id === "string" ? data.instance_id : null,
             launcher_pid: Number.isInteger(Number(data.launcher_pid)) ? Number(data.launcher_pid) : null,
-            reason: healthy ? null : "Watcher heartbeat is stale. Restart the PatchWarden watcher.",
+            reason: "Watcher heartbeat is stale. Restart the PatchWarden watcher.",
+            activity: null,
         };
     }
     catch {
@@ -52,9 +100,53 @@ export function readWatcherStatus(config = getConfig(), nowMs = Date.now()) {
             instance_id: null,
             launcher_pid: null,
             reason: "Watcher heartbeat file is unreadable.",
+            activity: null,
         };
     }
 }
+function checkRunningTaskHeartbeat(config, nowMs, staleAfterSeconds) {
+    const tasksDir = getTasksDir(config);
+    if (!existsSync(tasksDir))
+        return null;
+    let entries;
+    try {
+        entries = readdirSync(tasksDir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const taskDir = join(tasksDir, entry.name);
+        const statusFile = join(taskDir, "status.json");
+        const runtimeFile = join(taskDir, "runtime.json");
+        if (!existsSync(statusFile) || !existsSync(runtimeFile))
+            continue;
+        try {
+            const status = JSON.parse(readFileSync(statusFile, "utf-8"));
+            if (status.status !== "running")
+                continue;
+            const runtime = JSON.parse(readFileSync(runtimeFile, "utf-8"));
+            const heartbeatAt = String(runtime.last_heartbeat_at || "");
+            const heartbeatMs = Date.parse(heartbeatAt);
+            if (!Number.isFinite(heartbeatMs))
+                continue;
+            const ageMs = Math.max(0, nowMs - heartbeatMs);
+            if (ageMs < staleAfterSeconds * 1000) {
+                return {
+                    heartbeat_at: heartbeatAt,
+                    age_seconds: Math.round(ageMs / 1000),
+                    activity: `watcher busy executing task ${entry.name}`,
+                };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
 export function derivePendingReason(task, watcher) {
     if (task.status === "pending") {
         if (watcher.status === "stale")