patchwarden 1.6.1 → 1.6.2

package/src/tools/tasks/reconcileTasks.ts

@@ -11,8 +11,11 @@ import { getTasksDir, getConfig, type PatchWardenConfig } from "../../config.js"
 import { diagnoseTask, type DiagnosisType, type DiagnosisConfidence, type SafeAction } from "./diagnoseTask.js";
 import { syncSubgoalOnTaskDone, readTaskGoalMeta } from "../../goal/subgoalSync.js";
 import { mutateTaskStatus } from "../../runner/taskStatusStore.js";
-import { atomicWriteFileSync } from "../../utils/atomicFile.js";
+import { writeTaskRuntime } from "../../runner/taskRuntime.js";
+import type { TaskPhase } from "./createTask.js";
+import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
 import { appendBoundedTextFileSync } from "../../utils/boundedFile.js";
+import { isActiveTaskStatus } from "./taskStates.js";
 
 // ── v0.7.0: reconcile_tasks types ──────────────────────────────────
 
@@ -22,6 +25,7 @@ export interface ReconcileTasksInput {
   max_age_minutes?: number;
   mode?: ReconcileMode;
   include_done_candidates?: boolean;
+  task_ids?: string[];
 }
 
 export interface ReconcileTaskReport {
@@ -33,7 +37,7 @@ export interface ReconcileTaskReport {
   reasons: string[];
   safe_actions: SafeAction[];
   age_seconds: number | null;
-  action_taken: "left_unchanged" | "marked_failed_stale" | "marked_orphaned" | "marked_done_by_agent";
+  action_taken: "left_unchanged" | "marked_failed_stale" | "marked_orphaned" | "marked_done_by_agent" | "marked_canceled" | "marked_timed_out";
   previous_status: string | null;
   new_status: string | null;
   applied_at: string | null;
@@ -75,6 +79,9 @@ export function reconcileTasks(
       ? Math.min(input.max_age_minutes, 24 * 60)
       : DEFAULT_MAX_AGE_MINUTES;
   const includeDoneCandidates = input.include_done_candidates !== false; // default true
+  const requestedTaskIds = input.task_ids?.length
+    ? new Set(input.task_ids.filter((taskId) => /^task[-_][a-zA-Z0-9_-]+$/.test(taskId)))
+    : null;
   const maxAgeSeconds = maxAgeMinutes * 60;
 
   const tasksDir = getTasksDir(config);
@@ -118,8 +125,9 @@ export function reconcileTasks(
   const taskDirs = entries.filter((e) => e.isDirectory());
 
   for (const entry of taskDirs) {
-    scanned += 1;
     const taskId = entry.name;
+    if (requestedTaskIds && !requestedTaskIds.has(taskId)) continue;
+    scanned += 1;
     const taskDir = resolve(tasksDir, taskId);
     const statusFile = join(taskDir, "status.json");
     if (!existsSync(statusFile)) continue;
@@ -133,18 +141,17 @@ export function reconcileTasks(
 
     const statusStr = typeof statusData.status === "string" ? statusData.status : "unknown";
 
-    // Filter: only running / collecting_artifacts / (optionally) done_by_agent candidates
+    // Scan every persisted non-terminal lifecycle spelling, including legacy
+    // phase-as-status records left by older Watchers.
     const isCandidate =
-      statusStr === "running" ||
-      statusStr === "collecting_artifacts" ||
+      isActiveTaskStatus(statusStr) ||
       (includeDoneCandidates && statusStr === "done_by_agent");
     if (!isCandidate) continue;
 
-    // Filter by age — use the oldest reliable timestamp on the task
+    // Use the oldest reliable timestamp for ordinary stale detection. Explicit
+    // cancel, persisted deadline, and Watcher-instance mismatch bypass this
+    // age gate so a restart cannot extend the task's total budget.
     const ageSeconds = taskAgeSeconds(taskDir, statusData, nowMs);
-    if (ageSeconds !== null && ageSeconds < maxAgeSeconds) continue;
-
-    candidates += 1;
 
     // Diagnose the task
     let diagnosis;
@@ -153,6 +160,14 @@ export function reconcileTasks(
     } catch {
       continue; // diagnosis failed — skip
     }
+    const cancellationRequested = statusData.cancel_requested === true || statusStr === "cancel_requested";
+    const deadlineExceeded = taskDeadlineExceeded(statusData, nowMs);
+    const urgentRecovery = cancellationRequested
+      || deadlineExceeded
+      || diagnosis.diagnosis === "orphaned_running";
+    if (ageSeconds !== null && ageSeconds < maxAgeSeconds && !urgentRecovery) continue;
+
+    candidates += 1;
 
     const report: ReconcileTaskReport = {
       task_id: taskId,
@@ -188,7 +203,9 @@ export function reconcileTasks(
     //
     // Anything else is left_unchanged and recorded for audit.
 
-    if (mode === "safe_fix" && diagnosis.confidence === "high") {
+    const deterministicRecovery = !diagnosis.evidence.watcher_owns_task
+      && (cancellationRequested || deadlineExceeded);
+    if (mode === "safe_fix" && (diagnosis.confidence === "high" || deterministicRecovery)) {
       if (diagnosis.evidence.watcher_owns_task) {
         // Hard rule: do not touch tasks the live watcher still owns.
         skippedActiveWatcher += 1;
@@ -284,7 +301,14 @@ function applySafeFix(
   let newStatus: string | null = null;
   let actionTaken: ReconcileTaskReport["action_taken"] = "left_unchanged";
 
-  switch (diagnosis) {
+  const cancellationRequested = currentStatus.cancel_requested === true || previousStatus === "cancel_requested";
+  if (!evidence.watcher_owns_task && cancellationRequested) {
+    newStatus = "canceled";
+    actionTaken = "marked_canceled";
+  } else if (!evidence.watcher_owns_task && taskDeadlineExceeded(currentStatus)) {
+    newStatus = "timeout";
+    actionTaken = "marked_timed_out";
+  } else switch (diagnosis) {
     case "stale_running":
       newStatus = "failed_stale";
       actionTaken = "marked_failed_stale";
@@ -350,8 +374,32 @@ function applySafeFix(
             current_watcher_instance_id: evidence.current_watcher_instance_id,
           },
         },
+        process_cleanup_required: !evidence.watcher_owns_task,
+        process_cleanup_reason: !evidence.watcher_owns_task
+          ? "The previous runner is no longer owned by this Watcher; child-process termination could not be confirmed and no untrusted PID was killed."
+          : null,
       };
 
+      if (newStatus === "canceled") {
+        next.canceled_at = appliedAt;
+        next.cancel_reason = "Cancellation converged after the original task runner stopped responding.";
+        next.termination_reason = "canceled";
+        next.error_code = "runner_lost_during_cancel";
+      } else if (actionTaken === "marked_timed_out") {
+        next.error = `Task exceeded its configured timeout of ${Number(current.timeout_seconds)} seconds after the original runner stopped responding.`;
+        next.termination_reason = "timeout";
+        next.error_code = "task_timeout";
+      } else if (diagnosis === "artifact_collection_stuck") {
+        next.error = "Artifact collection was interrupted and could not be safely resumed after the original runner stopped responding.";
+        next.error_code = "artifact_collection_interrupted";
+      } else if (diagnosis === "orphaned_running") {
+        next.error = "The original task runner was lost and its child process ownership could not be re-established.";
+        next.error_code = "agent_lost";
+      } else if (diagnosis === "stale_running") {
+        next.error = "The task runner heartbeat expired and no current Runner ownership could be proven.";
+        next.error_code = "agent_lost";
+      }
+
       if (newStatus === "done_by_agent") {
         next.acceptance_status = "pending";
         next.legacy_status = "done";
@@ -359,7 +407,7 @@ function applySafeFix(
 
       // The backup is created while the same lock protects the exact record
       // being replaced, so it cannot capture an unrelated newer state.
-      atomicWriteFileSync(backupFile, readFileSync(statusFile, "utf-8"));
+      if (!existsSync(backupFile)) atomicWriteFileSync(backupFile, readFileSync(statusFile, "utf-8"));
       return {
         next,
         result: { applied: true as const },
@@ -386,6 +434,22 @@ function applySafeFix(
     };
   }
 
+  if (newStatus !== "done_by_agent") {
+    writeRecoveryArtifacts(taskDir, taskId, currentStatus, newStatus, actionTaken, appliedAt);
+  }
+
+  // Keep the persisted runtime view terminal as well. get_task_status merges
+  // runtime.json over status.json, so leaving an old executing phase here
+  // would make a successfully reconciled task appear active again.
+  writeTaskRuntime(taskDir, {
+    phase: newStatus as TaskPhase,
+    current_command: null,
+    last_heartbeat_at: appliedAt,
+    child_pid: undefined,
+    child_started_at: undefined,
+    child_owned_by_runner_instance_id: undefined,
+  });
+
   // v0.8.0: 当状态变为 done_by_agent 时，同步关联 subgoal 状态（running → done_by_agent）
   if (newStatus === "done_by_agent") {
     const goalMeta = readTaskGoalMeta(taskDir);
@@ -404,6 +468,91 @@ function applySafeFix(
   };
 }
 
+function writeRecoveryArtifacts(
+  taskDir: string,
+  taskId: string,
+  status: Record<string, unknown>,
+  newStatus: string,
+  actionTaken: ReconcileTaskReport["action_taken"],
+  recoveredAt: string,
+): void {
+  const timeoutSeconds = Number(status.timeout_seconds);
+  const summary = actionTaken === "marked_timed_out"
+    ? `Task exceeded its configured timeout of ${timeoutSeconds} seconds after the original runner stopped responding.`
+    : actionTaken === "marked_canceled"
+      ? "Cancellation converged after the original task runner stopped responding."
+      : `Task was reconciled to ${newStatus} after the original runner stopped responding.`;
+  const errorCode = actionTaken === "marked_timed_out"
+    ? "task_timeout"
+    : actionTaken === "marked_canceled"
+      ? "runner_lost_during_cancel"
+      : newStatus === "orphaned"
+        ? "agent_lost"
+        : newStatus === "failed_stale" && String(status.phase || status.status) === "collecting_artifacts"
+          ? "artifact_collection_interrupted"
+          : "agent_lost";
+  const requestedCommands = Array.isArray(status.verify_commands)
+    ? status.verify_commands.map(String)
+    : [];
+  const artifacts = {
+    "verify.json": {
+      status: "failed",
+      requested_commands: requestedCommands,
+      commands: [],
+      failure_reason: "runner_recovery",
+      error_code: errorCode,
+    },
+    "result.json": {
+      task_id: taskId,
+      status: newStatus,
+      agent: status.agent || "",
+      repo_path: status.repo_path || "",
+      resolved_repo_path: status.resolved_repo_path || "",
+      summary,
+      artifact_status: "partial",
+      changed_files: [],
+      diff_available: false,
+      verify_status: "failed",
+      failure_reason: "runner_recovery",
+      error_code: errorCode,
+      termination_reason: actionTaken === "marked_timed_out"
+        ? "timeout"
+        : actionTaken === "marked_canceled"
+          ? "canceled"
+          : "runner_stale",
+      recovered_at: recoveredAt,
+      warnings: ["The original runner stopped before complete change and verification evidence could be collected."],
+    },
+  };
+  for (const [name, value] of Object.entries(artifacts)) {
+    const path = join(taskDir, name);
+    if (!existsSync(path)) atomicWriteJsonFileSync(path, value);
+  }
+  const textArtifacts: Record<string, string> = {
+    "result.md": `# PatchWarden Task Result\n\n## Status\n${newStatus}\n\n## Summary\n${summary}\n\n## Artifact Status\npartial\n`,
+    "test.log": `(not run)\nExit code: not run\n${summary}\n`,
+    "git.diff": `(unavailable: ${summary})\n`,
+    "diff.patch": `(unavailable: ${summary})\n`,
+  };
+  for (const [name, content] of Object.entries(textArtifacts)) {
+    const path = join(taskDir, name);
+    if (!existsSync(path)) atomicWriteFileSync(path, content);
+  }
+}
+
+function taskDeadlineExceeded(status: Record<string, unknown>, nowMs = Date.now()): boolean {
+  const timeoutSeconds = Number(status.timeout_seconds);
+  const startedAt = typeof status.started_at === "string"
+    ? Date.parse(status.started_at)
+    : typeof status.created_at === "string"
+      ? Date.parse(status.created_at)
+      : NaN;
+  return Number.isFinite(startedAt)
+    && Number.isFinite(timeoutSeconds)
+    && timeoutSeconds > 0
+    && nowMs >= startedAt + timeoutSeconds * 1000;
+}
+
 // ── reconcile.log writer ───────────────────────────────────────────
 
 function writeReconcileLog(

package/src/tools/tasks/runTaskLoop.ts

@@ -9,6 +9,7 @@ import { runDirectVerificationBundle } from "../direct/runDirectVerificationBund
 import { waitForTask } from "./waitForTask.js";
 import { safeAudit, safeAuditDirectSession, safeFinalizeDirectSession, safeResult, safeTestSummary } from "../diagnostics/safeViews.js";
 import type { TaskTemplateName } from "../taskTemplates.js";
+import { isTerminalTaskStatus } from "./taskStates.js";
 import {
   createLineageId,
   writeTaskLineage,
@@ -86,16 +87,6 @@ const DEFAULT_DEPS: RunTaskLoopDeps = {
   sleep,
 };
 
-const TERMINAL_STATUSES = new Set([
-  "done",
-  "done_by_agent",
-  "failed",
-  "failed_verification",
-  "failed_scope_violation",
-  "failed_policy_violation",
-  "canceled",
-]);
-
 export async function runTaskLoop(input: RunTaskLoopInput): Promise<RunTaskLoopOutput> {
   return runTaskLoopWithDeps(input, DEFAULT_DEPS);
 }
@@ -273,7 +264,7 @@ async function waitUntilTerminal(
   const deadline = Date.now() + timeoutSeconds * 1000;
   while (Date.now() < deadline) {
     const waited = await deps.waitForTask(taskId, 30);
-    if (waited.terminal || TERMINAL_STATUSES.has(String(waited.status))) {
+    if (waited.terminal || isTerminalTaskStatus(String(waited.status))) {
       return { next_action: waited.next_action || "safe_audit" };
     }
     if (waited.next_tool_call?.name === "health_check" || waited.continuation_required === false) {
@@ -340,7 +331,7 @@ function isSuccessfulRound(round: TaskLineageRound): boolean {
 }
 
 function isHardStop(round: TaskLineageRound, resultValue: unknown, auditValue: unknown, stopOnHighRisk: boolean): boolean {
-  if (["failed_scope_violation", "failed_policy_violation", "canceled"].includes(round.status)) return true;
+  if (["failed_scope_violation", "failed_policy_violation", "canceled", "timeout"].includes(round.status)) return true;
   if (!stopOnHighRisk) return false;
   const checkNames = [...round.fail_checks, ...round.warn_checks].join(" ").toLowerCase();
   const result = asRecord(resultValue);
@@ -352,6 +343,7 @@ function isHardStop(round: TaskLineageRound, resultValue: unknown, auditValue: u
 function hardStopReason(round: TaskLineageRound, resultValue: unknown): TaskLoopStopReason {
   const result = asRecord(resultValue);
   if (round.status === "failed_scope_violation" || round.status === "failed_policy_violation") return "policy_blocked";
+  if (round.status === "timeout") return "agent_timeout";
   if (String(result.failure_reason || "").toLowerCase().includes("timeout")) return "agent_timeout";
   return "high_risk_blocked";
 }

package/src/tools/tasks/taskStates.ts

@@ -0,0 +1,54 @@
+export const ACTIVE_TASK_STATUSES = new Set([
+  "pending",
+  "running",
+  "executing_agent",
+  "verifying",
+  "collecting_artifacts",
+  "cancel_requested",
+]);
+
+export const TERMINAL_TASK_STATUSES = new Set([
+  "done",
+  "done_by_agent",
+  "accepted",
+  "rejected",
+  "needs_fix",
+  "blocked",
+  "failed",
+  "failed_verification",
+  "failed_scope_violation",
+  "failed_policy_violation",
+  "failed_stale",
+  "orphaned",
+  "timeout",
+  "canceled",
+]);
+
+export function isTerminalTaskStatus(status: string): boolean {
+  return TERMINAL_TASK_STATUSES.has(status);
+}
+
+export function isActiveTaskStatus(status: string): boolean {
+  return ACTIVE_TASK_STATUSES.has(status);
+}
+
+/** Terminal states are immutable; active states may only advance or terminate. */
+export function isAllowedTaskStatusTransition(from: string, to: string): boolean {
+  if (from === to) return true;
+  if (isTerminalTaskStatus(from)) return false;
+  if (!isActiveTaskStatus(from) || !isActiveTaskStatus(to) && !isTerminalTaskStatus(to)) return false;
+
+  if (from === "pending") {
+    return to === "running" || isTerminalTaskStatus(to);
+  }
+  if (to === "pending") return false;
+
+  const forwardActive: Record<string, Set<string>> = {
+    running: new Set(["executing_agent", "verifying", "collecting_artifacts", "cancel_requested"]),
+    executing_agent: new Set(["verifying", "collecting_artifacts", "cancel_requested"]),
+    verifying: new Set(["collecting_artifacts", "cancel_requested"]),
+    collecting_artifacts: new Set(["cancel_requested"]),
+    cancel_requested: new Set(),
+  };
+  return isTerminalTaskStatus(to) || Boolean(forwardActive[from]?.has(to));
+}

package/src/tools/tasks/waitForTask.ts

@@ -1,16 +1,7 @@
 import { setTimeout as sleep } from "node:timers/promises";
 import { getTaskStatus } from "./getTaskStatus.js";
 import { getTaskSummary, type TaskSummaryResult } from "./getTaskSummary.js";
-
-const TERMINAL_STATUSES = new Set([
-  "done",
-  "done_by_agent",
-  "failed",
-  "failed_verification",
-  "failed_scope_violation",
-  "failed_policy_violation",
-  "canceled",
-]);
+import { isTerminalTaskStatus } from "./taskStates.js";
 
 export interface WaitForTaskProgressSummary {
   phase: string;
@@ -45,12 +36,12 @@ export async function waitForTask(taskId: string, waitSeconds = 25): Promise<Wai
   const deadline = started + waitSeconds * 1000;
   let status = getTaskStatus(taskId);
 
-  while (!TERMINAL_STATUSES.has(status.status) && Date.now() < deadline) {
+  while (!isTerminalTaskStatus(status.status) && Date.now() < deadline) {
     await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
     status = getTaskStatus(taskId);
   }
 
-  const terminal = TERMINAL_STATUSES.has(status.status);
+  const terminal = isTerminalTaskStatus(status.status);
   const executionBlocked = !terminal && status.execution_blocked;
   const elapsed = Math.round((Date.now() - started) / 1000);
 

package/src/tools/workspace/listAgents.ts

@@ -1,5 +1,5 @@
 import { existsSync, statSync } from "node:fs";
-import { basename, delimiter, extname, isAbsolute, join } from "node:path";
+import { basename, delimiter, extname, isAbsolute, join, resolve } from "node:path";
 import { getConfig } from "../../config.js";
 import { sanitizeTrustedPath } from "../../runner/processSecurity.js";
 
@@ -13,15 +13,25 @@ export interface AgentAvailability {
   adapter: string | null;
   model: string | null;
   capabilities: { model_override: boolean };
+  availability_scope: "executable_only";
+  provider_status: "not_checked";
+  invocation_ready?: boolean;
+  model_argument_present?: boolean;
 }
 
-export function listAgents(): { agents: AgentAvailability[]; total: number } {
+export function listAgents(): { agents: AgentAvailability[]; total: number; config_path: string; workspace_root: string } {
   const config = getConfig();
   const checkedAt = new Date().toISOString();
+  const configPath = process.env.PATCHWARDEN_CONFIG
+    ? resolve(process.env.PATCHWARDEN_CONFIG)
+    : resolve(process.cwd(), "patchwarden.config.json");
   const agents = Object.entries(config.agents)
     .sort(([left], [right]) => left.localeCompare(right))
     .map(([name, agent]) => {
       const available = commandExists(agent.command, config.workspaceRoot);
+      const modelArgumentPresent = typeof agent.model === "string"
+        ? agent.args.some((arg, index) => arg === "--model" && agent.args[index + 1] === agent.model)
+        : true;
       return {
         name,
         configured: true as const,
@@ -32,9 +42,13 @@ export function listAgents(): { agents: AgentAvailability[]; total: number } {
         adapter: typeof agent.adapter === "string" ? agent.adapter : ["codex", "opencode"].includes(name) ? name : null,
         model: typeof agent.model === "string" ? agent.model : null,
         capabilities: { model_override: typeof agent.adapter === "string" || ["codex", "opencode"].includes(name) },
+        availability_scope: "executable_only" as const,
+        provider_status: "not_checked" as const,
+        invocation_ready: available && modelArgumentPresent,
+        model_argument_present: modelArgumentPresent,
       };
     });
-  return { agents, total: agents.length };
+  return { agents, total: agents.length, config_path: configPath, workspace_root: config.workspaceRoot };
 }
 
 function commandExists(command: string, workspaceRoot: string): boolean {

package/src/utils/atomicFile.ts

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { renameSync, rmSync, writeFileSync } from "node:fs";
+import { closeSync, fsyncSync, openSync, renameSync, rmSync, writeFileSync } from "node:fs";
 
 export interface AtomicWriteOptions {
   encoding?: BufferEncoding;
@@ -24,6 +24,22 @@ export function atomicWriteFileSync(
       flag: "wx",
       ...(options.mode === undefined ? {} : { mode: options.mode }),
     });
+    const descriptor = openSync(temporaryPath, "r");
+    try {
+      try {
+        fsyncSync(descriptor);
+      } catch (error) {
+        const code = error && typeof error === "object" && "code" in error
+          ? String((error as NodeJS.ErrnoException).code || "")
+          : "";
+        // Some Windows filesystems and restricted runtimes reject fsync even
+        // after a successful complete write. Keep the same-directory atomic
+        // rename guarantee there; unexpected I/O errors still fail closed.
+        if (!new Set(["EPERM", "EINVAL", "ENOSYS", "ENOTSUP"]).has(code)) throw error;
+      }
+    } finally {
+      closeSync(descriptor);
+    }
     replaceFileSync(temporaryPath, path);
   } catch (error) {
     try { rmSync(temporaryPath, { force: true }); } catch { /* best effort */ }

package/src/version.ts

@@ -1,3 +1,3 @@
-export const PATCHWARDEN_VERSION = "1.6.1";
+export const PATCHWARDEN_VERSION = "1.6.2";
 export const TOOL_SCHEMA_EPOCH = "2026-07-19-v15";
 export const ARTIFACT_SCHEMA_VERSION = TOOL_SCHEMA_EPOCH;

package/ui/pages/dashboard.html

@@ -1132,6 +1132,7 @@ html.dark {
       const svc = (status && status[prefix]) || {};
       const tunnel = (status && status.tunnel && status.tunnel[prefix]) || {};
       const tools = (status && status.tools && status.tools[prefix]) || {};
+      const connection = (status && status.connections && status.connections[prefix]) || {};
 
       const available = !!svc.available;
       const kind = available ? 'success' : 'error';
@@ -1140,6 +1141,9 @@ html.dark {
       const reasonText = svc.reason ? escapeHtml(svc.reason) : '—';
 
       const rows = [
+        { label: 'profile', html: connection.profile ? escapeHtml(connection.profile) : '—' },
+        { label: 'tunnel_id', html: connection.tunnel_id_masked ? escapeHtml(connection.tunnel_id_masked) : '—' },
+        { label: 'reconnect', html: connection.reconnect_guidance ? escapeHtml(connection.reconnect_guidance) : '—' },
         { label: 'PID', html: tunnel.pid != null ? escapeHtml(tunnel.pid) : '—' },
         { label: 'tool_profile', html: tools.tool_profile ? escapeHtml(tools.tool_profile) : '—' },
         { label: 'tool_count', html: tools.tool_count != null ? escapeHtml(tools.tool_count) : '—' },

package/ui/pages/logs.html

@@ -97,6 +97,35 @@ html.dark {
     <script src="/vendor/tailwindcss-browser.js"></script>
   <script src="/vendor/lucide.js"></script>
   <script src="/log-parser.js"></script>
+  <script>
+    // Keep the log page usable when an older packaged Control Center omits the
+    // parser asset. The server serves the canonical parser; this is only a
+    // bounded display fallback and never changes log contents.
+    if (!window.PatchWardenLogParser || typeof window.PatchWardenLogParser.parseLine !== 'function') {
+      window.PatchWardenLogParser = {
+        parseLine: function (rawLine, stream) {
+          var line = String(rawLine || '');
+          var source = String(stream || 'log');
+          var entry = null;
+          try {
+            var parsed = JSON.parse(line);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) entry = parsed;
+          } catch (_) {}
+          var level = entry ? String(entry.level || entry.severity || '').toLowerCase() : '';
+          if (level === 'warning') level = 'warn';
+          return {
+            raw: line,
+            time: entry ? String(entry.time || entry.timestamp || '') : '',
+            level: level,
+            component: entry ? String(entry.component || entry.scope || entry.source || source) : source,
+            summary: entry ? String(entry.summary || entry.msg || entry.message || line) : line,
+            detail: entry ? JSON.stringify(entry, null, 2) : line,
+            structured: entry !== null
+          };
+        }
+      };
+    }
+  </script>
     <style>
       .no-scrollbar::-webkit-scrollbar { display: none; }
       .no-scrollbar { -ms-overflow-style: none; scrollbar-width: none; }

package/ui/pages/settings.html

@@ -45,7 +45,7 @@
         <section>
           <h2 data-i18n="settings.mcpTunnel"></h2>
           <div class="setting-row">
-            <div class="min-w-0"><strong>tunnel-client.exe</strong><p id="tunnelClientPath" class="mono break-path" data-i18n="settings.tunnelUndetected"></p></div>
+            <div class="min-w-0"><strong>tunnel-client.exe</strong><p id="tunnelClientPath" class="mono break-path"></p></div>
             <div class="inline-actions"><button id="detectTunnel"><i data-lucide="scan-search"></i><span data-i18n="settings.detect"></span></button><button id="chooseTunnel"><i data-lucide="file-search"></i><span data-i18n="settings.choose"></span></button></div>
           </div>
           <div class="setting-row">
@@ -82,8 +82,8 @@
         </section>
         <section>
           <h2 data-i18n="settings.workspaceDiagnostics"></h2>
-          <div class="setting-row"><div class="min-w-0"><strong data-i18n="settings.currentConfig"></strong><p id="configPath" class="mono truncate" data-i18n="settings.loading"></p></div><button id="openConfig" data-i18n-title="settings.openConfig"><i data-lucide="external-link"></i></button></div>
-          <div class="setting-row"><div><strong data-i18n="settings.workspace"></strong><p id="workspacePath" class="mono" data-i18n="settings.workspaceHelp"></p></div><button id="changeWorkspace" data-i18n="settings.change"></button></div>
+          <div class="setting-row"><div class="min-w-0"><strong data-i18n="settings.currentConfig"></strong><p id="configPath" class="mono truncate"></p></div><button id="openConfig" data-i18n-title="settings.openConfig"><i data-lucide="external-link"></i></button></div>
+          <div class="setting-row"><div><strong data-i18n="settings.workspace"></strong><p id="workspacePath" class="mono"></p></div><button id="changeWorkspace" data-i18n="settings.change"></button></div>
           <div class="setting-actions"><button id="openLogs"><i data-lucide="folder-open"></i><span data-i18n="settings.openLogs"></span></button><button id="runDoctor"><i data-lucide="stethoscope"></i><span data-i18n="settings.runDoctor"></span></button></div>
           <pre id="doctorOutput" class="hidden"></pre>
         </section>

package/ui/settings.js

@@ -108,28 +108,37 @@
     syncProxyControls();
   }
 
-  api.getState().then(function (state) {
-    document.getElementById("configPath").textContent = state.configPath || tr("settings.notConfigured");
-    theme.value = state.preferences.theme;
-    language.value = state.preferences.language || "system";
-    closeBehavior.value = state.preferences.closeBehavior;
-    if (state.runtimeSettings) renderRuntime(state.runtimeSettings);
-  });
-  api.getRuntimeSettings().then(function (settings) {
-    renderRuntime(settings);
-    if (!settings.tunnelClientPath) {
-      setRuntimeMessage("settings.autoDetecting");
-      return api.detectTunnelClient().then(function (result) {
-        if (result.available) {
-          selectedTunnelPath = result.path;
-          tunnelClientPath.textContent = tr("settings.autoDetectedPath", { path: result.path, source: result.source });
+  async function initializeSettings() {
+    try {
+      var state = await api.getState();
+      var settings = state.runtimeSettings || await api.getRuntimeSettings();
+      renderRuntime(settings);
+      document.getElementById("configPath").textContent = state.configPath || tr("settings.notConfigured");
+      document.getElementById("workspacePath").textContent = state.workspaceRoot || tr("settings.workspaceHelp");
+      theme.value = state.preferences.theme;
+      language.value = state.preferences.language || "system";
+      closeBehavior.value = state.preferences.closeBehavior;
+
+      if (!settings.tunnelClientPath && state.tunnelClient && state.tunnelClient.available) {
+        selectedTunnelPath = state.tunnelClient.path;
+        tunnelClientPath.textContent = tr("settings.autoDetectedPath", { path: state.tunnelClient.path, source: state.tunnelClient.source });
+        setRuntimeMessage("settings.autoDetected");
+      } else if (!settings.tunnelClientPath) {
+        setRuntimeMessage("settings.autoDetecting");
+        var detected = await api.detectTunnelClient();
+        if (detected.available) {
+          selectedTunnelPath = detected.path;
+          tunnelClientPath.textContent = tr("settings.autoDetectedPath", { path: detected.path, source: detected.source });
           setRuntimeMessage("settings.autoDetected");
         } else {
           setRuntimeMessage("settings.tunnelNotFound");
         }
-      });
+      }
+    } catch (error) {
+      runtimeStatus.textContent = error && error.message ? error.message : tr("settings.loadFailed");
     }
-  }).catch(function (error) { runtimeStatus.textContent = error.message; });
+  }
+  void initializeSettings();
   void loadAgents(false);
   document.getElementById("detectAgents").addEventListener("click", function () { void loadAgents(true); });
   document.getElementById("saveAgents").addEventListener("click", async function () {