patchwarden 1.5.1 → 1.6.2

package/src/control/routes/tasks.ts

@@ -10,9 +10,8 @@
 import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { type ServerResponse } from "node:http";
-import { listTasks, type TaskEntry } from "../../tools/listTasks.js";
-import type { AcceptanceStatus } from "../../tools/createTask.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,
@@ -20,11 +19,12 @@ import {
   fileMtimeIso,
   isValidTaskId,
   parseReviewVerdict,
+  reconstructTaskEntry,
   readWatcherStatusSafe,
   StaleClassification,
   TERMINAL_TASK_STATUSES,
 } from "../runtime.js";
-import { config, errorMessage, readJsonFileSafe, readTextFileSafe, sendJson } from "../shared.js";
+import { config, errorMessage, guardControlPath, readJsonFileSafe, readTextFileSafe, sendJson } from "../shared.js";
 
 export interface TaskFilters {
   repo_path?: string;
@@ -32,6 +32,10 @@ export interface TaskFilters {
   acceptance_status?: string;
   agent?: string;
   warning_type?: string;
+  date_from?: string;
+  date_to?: string;
+  limit?: number;
+  cursor?: string;
 }
 
 export function handleTasks(res: ServerResponse, filters?: TaskFilters): void {
@@ -40,6 +44,7 @@ export function handleTasks(res: ServerResponse, filters?: TaskFilters): void {
     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) {
@@ -66,21 +71,58 @@ export function handleTasks(res: ServerResponse, filters?: TaskFilters): void {
       }
       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,
     });
@@ -89,6 +131,10 @@ export function handleTasks(res: ServerResponse, filters?: TaskFilters): void {
       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),
@@ -156,9 +202,13 @@ export function handleStaleTasks(res: ServerResponse): void {
 
 export function handleTaskDetail(res: ServerResponse, taskId: string): void {
   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;
     }
@@ -204,33 +254,7 @@ export function handleTaskDetail(res: ServerResponse, taskId: string): void {
     let stale: StaleClassification | null = 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 as AcceptanceStatus) : "pending" as AcceptanceStatus)
-        : null;
-      const entry: TaskEntry = {
-        task_id: taskId,
-        plan_id: String(statusData.plan_id || ""),
-        title: "",
-        agent: String(statusData.agent || ""),
-        status: taskStatus2 as TaskEntry["status"],
-        phase: String(runtimeData?.phase || statusData.phase || "queued") as TaskEntry["phase"],
-        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 as string[]) : [],
-        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);
     }
 
@@ -264,11 +288,7 @@ export function handleTaskSafeResult(res: ServerResponse, taskId: string): void
       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) });
   }
@@ -280,11 +300,7 @@ export function handleTaskSafeAudit(res: ServerResponse, taskId: string): void {
       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) });
   }
@@ -296,11 +312,7 @@ export function handleTaskSafeTestSummary(res: ServerResponse, taskId: string):
       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) });
   }
@@ -312,11 +324,7 @@ export function handleTaskSafeDiffSummary(res: ServerResponse, taskId: string):
       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) });
   }

package/src/control/routes/workspace.ts

@@ -10,14 +10,16 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { execFile } from "node:child_process";
 import { type ServerResponse } from "node:http";
-import { type AgentAvailability, listAgents } from "../../tools/listAgents.js";
+import { type AgentAvailability, listAgents } from "../../tools/workspace/listAgents.js";
 import { resolveWorkspaceRoot } from "../../config.js";
 import { guardWorkspacePath } from "../../security/pathGuard.js";
+import { buildGitEnvironment, redactProcessOutput, resolveTrustedExecutable } from "../../runner/processSecurity.js";
 import { config, errorMessage, sendJson } from "../shared.js";
 
 export function handleWorkspace(res: ServerResponse): void {
   let workspaceRoot: string | null = null;
   let directories: string[] = [];
+  let internalDirectories: string[] = [];
   let agents: AgentAvailability[] = [];
   let configSummary: { toolProfile: string | null; allowedTestCommandsCount: number; enableDirectProfile: boolean } | null = null;
 
@@ -28,10 +30,16 @@ export function handleWorkspace(res: ServerResponse): void {
   }
   if (workspaceRoot) {
     try {
-      directories = readdirSync(workspaceRoot, { withFileTypes: true })
-        .filter((e) => e.isDirectory())
-        .map((e) => e.name)
-        .sort();
+      const entries = readdirSync(workspaceRoot, { withFileTypes: true }).filter((e) => e.isDirectory());
+      for (const entry of entries) {
+        const child = join(workspaceRoot, entry.name);
+        const isInternal = entry.name.startsWith(".") || entry.name.startsWith("_");
+        const isGitRepo = existsSync(join(child, ".git"));
+        if (isGitRepo && !isInternal) directories.push(entry.name);
+        else internalDirectories.push(entry.name);
+      }
+      directories.sort();
+      internalDirectories.sort();
     } catch {
       directories = [];
     }
@@ -50,7 +58,7 @@ export function handleWorkspace(res: ServerResponse): void {
   } catch {
     configSummary = null;
   }
-  sendJson(res, 200, { workspace_root: workspaceRoot, directories, agents, config: configSummary });
+  sendJson(res, 200, { workspace_root: workspaceRoot, directories, internal_directories: internalDirectories, agents, config: configSummary });
 }
 
 interface WorkspaceRepoEntry {
@@ -130,8 +138,13 @@ export function handleWorkspaceRepoStatus(res: ServerResponse, repoParam: string
       return;
     }
 
-    // Reject obvious traversal in the raw parameter before resolving.
-    if (repoParam.includes("\0") || repoParam.includes("..")) {
+    // Reject parent traversal segments before resolving without rejecting
+    // otherwise valid names such as "release..candidate".
+    const hasParentTraversal = repoParam
+      .replace(/\\/g, "/")
+      .split("/")
+      .some((segment) => segment === "..");
+    if (repoParam.includes("\0") || hasParentTraversal) {
       sendJson(res, 400, { error: "Invalid repo path: traversal segments are not allowed" });
       return;
     }
@@ -151,31 +164,28 @@ export function handleWorkspaceRepoStatus(res: ServerResponse, repoParam: string
       return;
     }
 
-    // Only `git status --short` is permitted; no arbitrary git subcommand.
+    // Only porcelain status is permitted; no arbitrary git subcommand.
     // Timeout guards against a hung git prompt (e.g. credential dialog).
+    const env = buildGitEnvironment(repoAbs);
+    let git: string;
+    try {
+      git = resolveTrustedExecutable("git", repoAbs, { pathValue: env.PATH });
+    } catch (err) {
+      sendRepoStatusFailure(res, repoParam, repoAbs, err);
+      return;
+    }
     execFile(
-      "git",
-      ["status", "--short"],
-      { cwd: repoAbs, maxBuffer: 1024 * 1024, timeout: 8000, windowsHide: true, encoding: "utf-8" },
+      git,
+      ["status", "--porcelain=v1"],
+      { cwd: repoAbs, env, maxBuffer: 1024 * 1024, timeout: 8000, windowsHide: true, encoding: "utf-8" },
       (err, stdout, stderr) => {
         if (err) {
           // Not a git repo, git missing, or git errored — return a structured
           // failure rather than 500 so the UI can render it gracefully.
-          sendJson(res, 200, {
-            repo_path: repoParam,
-            resolved_repo_path: repoAbs,
-            is_git_repo: false,
-            changed_files_count: 0,
-            untracked_count: 0,
-            modified_count: 0,
-            is_clean: true,
-            short_status: "",
-            error: errorMessage(err),
-            stderr: stderr ? String(stderr).slice(0, 500) : "",
-          });
+          sendRepoStatusFailure(res, repoParam, repoAbs, err, stderr);
           return;
         }
-        const text = String(stdout);
+        const text = redactProcessOutput(String(stdout));
         const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
         let modified = 0;
         let untracked = 0;
@@ -201,3 +211,24 @@ export function handleWorkspaceRepoStatus(res: ServerResponse, repoParam: string
     sendJson(res, 500, { error: errorMessage(err) });
   }
 }
+
+function sendRepoStatusFailure(
+  res: ServerResponse,
+  repoParam: string,
+  repoAbs: string,
+  error: unknown,
+  stderr: unknown = "",
+): void {
+  sendJson(res, 200, {
+    repo_path: repoParam,
+    resolved_repo_path: repoAbs,
+    is_git_repo: false,
+    changed_files_count: 0,
+    untracked_count: 0,
+    modified_count: 0,
+    is_clean: true,
+    short_status: "",
+    error: redactProcessOutput(errorMessage(error)),
+    stderr: redactProcessOutput(String(stderr || "")).slice(0, 500),
+  });
+}

package/src/control/runtime.ts

@@ -7,15 +7,19 @@
  * file mtime, id validation). These are pure helpers consumed by the route
  * modules; they hold no HTTP-layer concerns beyond reusing `sendJson`.
  */
-import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { get as httpGet } from "node:http";
-import { listTasks, type TaskEntry } from "../tools/listTasks.js";
-import { listAgents, type AgentAvailability } from "../tools/listAgents.js";
+import { listTasks, type TaskEntry } from "../tools/tasks/listTasks.js";
+import { listAgents, type AgentAvailability } from "../tools/workspace/listAgents.js";
 import { readWatcherStatus, type WatcherStatusSnapshot } from "../watcherStatus.js";
 import { resolveWorkspaceRoot } from "../config.js";
 import { PATCHWARDEN_VERSION } from "../version.js";
+import { isValidDirectSessionId as isValidStoredDirectSessionId } from "../direct/directSessionStore.js";
+import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../utils/atomicFile.js";
+import { withFileLockSync } from "../utils/lockedJsonFile.js";
 import { logger } from "../logging.js";
+import { TERMINAL_TASK_STATUSES as SHARED_TERMINAL_TASK_STATUSES } from "../tools/tasks/taskStates.js";
 import {
   config,
   controlCenterEventsPath,
@@ -201,16 +205,7 @@ export interface StaleClassification {
   stale_reasons: string[];
 }
 
-export const TERMINAL_TASK_STATUSES = new Set([
-  "done",
-  "done_by_agent",
-  "failed",
-  "failed_verification",
-  "failed_scope_violation",
-  "failed_policy_violation",
-  "canceled",
-  "timeout",
-]);
+export const TERMINAL_TASK_STATUSES = SHARED_TERMINAL_TASK_STATUSES;
 
 /**
  * Classify a task as stale based on Phase 2 rules:
@@ -323,7 +318,7 @@ export function writeStatusFile(): void {
   };
   try {
     mkdirSync(getControlCenterLogDir(), { recursive: true });
-    writeFileSync(controlCenterStatusPath, JSON.stringify(status, null, 2), "utf-8");
+    atomicWriteJsonFileSync(controlCenterStatusPath, status);
   } catch (err) {
     logger.error("[control-center] Failed to write status file", { error: errorMessage(err) });
   }
@@ -359,29 +354,24 @@ export function recordEvent(type: string, payload?: Record<string, unknown>): vo
   };
   try {
     mkdirSync(getControlCenterLogDir(), { recursive: true });
-    appendFileSync(controlCenterEventsPath, JSON.stringify(event) + "\n", "utf-8");
+    withFileLockSync(controlCenterEventsPath, () => {
+      appendFileSync(controlCenterEventsPath, JSON.stringify(event) + "\n", "utf-8");
+      const stat = statSync(controlCenterEventsPath);
+      if (stat.size > 512 * 1024) trimEventsFileUnlocked();
+    });
   } catch (err) {
     logger.error("[control-center] Failed to write event", { error: errorMessage(err) });
   }
-  // Lazy trim: only when the file grows well past the cap.
-  try {
-    const stat = statSync(controlCenterEventsPath);
-    if (stat.size > 512 * 1024) {
-      trimEventsFile();
-    }
-  } catch {
-    /* ignore */
-  }
 }
 
-function trimEventsFile(): void {
+function trimEventsFileUnlocked(): void {
   try {
     if (!existsSync(controlCenterEventsPath)) return;
     const raw = readFileSync(controlCenterEventsPath, "utf-8");
     const lines = raw.split(/\r?\n/).filter((l) => l.length > 0);
     if (lines.length <= MAX_EVENT_LINES) return;
     const trimmed = lines.slice(lines.length - MAX_EVENT_LINES);
-    writeFileSync(controlCenterEventsPath, trimmed.join("\n") + "\n", "utf-8");
+    atomicWriteFileSync(controlCenterEventsPath, trimmed.join("\n") + "\n");
   } catch (err) {
     logger.error("[control-center] Failed to trim events file", { error: errorMessage(err) });
   }
@@ -412,13 +402,52 @@ export function readEvents(limit: number): ControlCenterEvent[] {
 export function readHiddenStaleIds(): string[] {
   const p = join(getControlCenterLogDir(), "hidden-stale-ids.json");
   if (!existsSync(p)) return [];
-  return readJsonFileSafe<string[]>(p) || [];
+  return readStoredStringArray(p);
+}
+
+export function reconstructTaskEntry(
+  taskId: string,
+  statusData: Record<string, unknown>,
+  runtimeData: Record<string, unknown> = {},
+  watcher: WatcherStatusSnapshot = readWatcherStatusSafe(),
+): TaskEntry {
+  const validAcceptance = new Set(["pending", "accepted", "rejected", "needs_fix", "blocked"]);
+  const taskStatus = String(statusData.status || "pending");
+  const acceptanceStatus = taskStatus === "done_by_agent"
+    ? (typeof statusData.acceptance_status === "string" && validAcceptance.has(statusData.acceptance_status)
+        ? statusData.acceptance_status
+        : "pending")
+    : null;
+  return {
+    task_id: taskId,
+    plan_id: String(statusData.plan_id || ""),
+    title: "",
+    agent: String(statusData.agent || ""),
+    status: taskStatus as TaskEntry["status"],
+    phase: String(runtimeData.phase || statusData.phase || "queued") as TaskEntry["phase"],
+    acceptance_status: acceptanceStatus as TaskEntry["acceptance_status"],
+    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.filter((command): command is string => typeof command === "string")
+      : [],
+    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,
+  };
 }
 
 export function writeHiddenStaleIds(ids: string[]): void {
   const dir = getControlCenterLogDir();
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "hidden-stale-ids.json"), JSON.stringify(ids, null, 2));
+  atomicWriteJsonFileSync(join(dir, "hidden-stale-ids.json"), normalizeStoredIds(ids));
 }
 
 // ── Hidden direct session IDs (local UI state) ────────────────────
@@ -426,32 +455,31 @@ export function writeHiddenStaleIds(ids: string[]): void {
 export function readHiddenDirectSessionIds(): string[] {
   const p = join(getControlCenterLogDir(), "hidden-direct-session-ids.json");
   if (!existsSync(p)) return [];
-  return readJsonFileSafe<string[]>(p) || [];
+  return readStoredStringArray(p);
 }
 
 export function writeHiddenDirectSessionIds(ids: string[]): void {
   const dir = getControlCenterLogDir();
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "hidden-direct-session-ids.json"), JSON.stringify(ids, null, 2));
+  atomicWriteJsonFileSync(join(dir, "hidden-direct-session-ids.json"), normalizeStoredIds(ids));
 }
 
 export function isValidDirectSessionId(sessionId: string): boolean {
-  // Allow alphanumeric, dash, underscore only — reject path traversal and NUL.
-  return (
-    sessionId.length > 0 &&
-    /^[A-Za-z0-9_-]+$/.test(sessionId) &&
-    !sessionId.includes("\0")
-  );
+  return isValidStoredDirectSessionId(sessionId);
 }
 
 export function isValidTaskId(taskId: string): boolean {
-  return !(
-    taskId === "." ||
-    taskId === ".." ||
-    taskId.includes("/") ||
-    taskId.includes("\\") ||
-    taskId.includes("\0")
-  );
+  return /^[A-Za-z0-9][A-Za-z0-9_-]{0,159}$/.test(taskId);
+}
+
+function readStoredStringArray(path: string): string[] {
+  const value = readJsonFileSafe<unknown>(path);
+  if (!Array.isArray(value)) return [];
+  return normalizeStoredIds(value);
+}
+
+function normalizeStoredIds(value: unknown[]): string[] {
+  return [...new Set(value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0))];
 }
 
 // ── Small shared helpers ──────────────────────────────────────────