bosun 0.40.2 → 0.40.4

package/server/ui-server.mjs

@@ -188,6 +188,12 @@ const TASK_STORE_DEPENDENCY_EXPORTS = {
   update: ["updateTask"],
 };
 const TASK_STORE_ASSIGN_SPRINT_EXPORTS = ["assignTaskToSprint", "setTaskSprint"];
+const TASK_STORE_EPIC_DEPENDENCY_EXPORTS = Object.freeze({
+  list: ["getEpicDependencies", "listEpicDependencies"],
+  set: ["setEpicDependencies", "updateEpicDependencies"],
+  add: ["addEpicDependency"],
+  remove: ["removeEpicDependency"],
+});
 let taskStoreApi = null;
 let taskStoreApiPromise = null;
 let didLogTaskStoreLoadFailure = false;
@@ -6154,6 +6160,68 @@ async function setTaskDependenciesForApi({
   };
 }
 
+async function listEpicDependenciesForApi() {
+  const listed = await callTaskStoreFunction(TASK_STORE_EPIC_DEPENDENCY_EXPORTS.list, []);
+  if (listed.found && Array.isArray(listed.value)) {
+    return {
+      ok: true,
+      source: `task-store.${listed.found}`,
+      data: listed.value
+        .map((entry) => ({
+          epicId: String(entry?.epicId || entry?.id || "").trim(),
+          dependencies: normalizeTaskIdList(entry?.dependencies || entry?.dependsOn || []),
+        }))
+        .filter((entry) => entry.epicId),
+    };
+  }
+  return { ok: false, source: null, data: [] };
+}
+
+async function setEpicDependenciesForApi({ epicId, dependencies }) {
+  const normalizedEpicId = String(epicId || "").trim();
+  if (!normalizedEpicId) return { ok: false, status: 400, error: "epicId required" };
+  const normalizedDependencies = normalizeTaskIdList(dependencies, { exclude: normalizedEpicId });
+
+  const setResult = await callTaskStoreFunction(
+    TASK_STORE_EPIC_DEPENDENCY_EXPORTS.set,
+    [normalizedEpicId, normalizedDependencies],
+  );
+  if (setResult.found) {
+    return {
+      ok: true,
+      source: `task-store.${setResult.found}`,
+      data: {
+        epicId: normalizedEpicId,
+        dependencies: normalizeTaskIdList(setResult.value?.dependencies || normalizedDependencies),
+      },
+    };
+  }
+
+  const listed = await listEpicDependenciesForApi();
+  const current = listed.ok
+    ? normalizeTaskIdList((listed.data.find((entry) => entry.epicId === normalizedEpicId) || {}).dependencies || [])
+    : [];
+
+  const toRemove = current.filter((entry) => !normalizedDependencies.includes(entry));
+  const toAdd = normalizedDependencies.filter((entry) => !current.includes(entry));
+
+  for (const dep of toRemove) {
+    await callTaskStoreFunction(TASK_STORE_EPIC_DEPENDENCY_EXPORTS.remove, [normalizedEpicId, dep]);
+  }
+  for (const dep of toAdd) {
+    await callTaskStoreFunction(TASK_STORE_EPIC_DEPENDENCY_EXPORTS.add, [normalizedEpicId, dep]);
+  }
+
+  const refreshed = await listEpicDependenciesForApi();
+  const row = refreshed.ok
+    ? refreshed.data.find((entry) => entry.epicId === normalizedEpicId)
+    : null;
+  return {
+    ok: true,
+    source: refreshed.source || "task-store.fallback",
+    data: { epicId: normalizedEpicId, dependencies: normalizeTaskIdList(row?.dependencies || []) },
+  };
+}
 async function getTaskCommentsForApi(taskId, adapter = null) {
   const storeComments = await callTaskStoreFunction(TASK_STORE_COMMENT_EXPORTS, [taskId]);
   if (storeComments.found && Array.isArray(storeComments.value)) {
@@ -6354,6 +6422,150 @@ function applyInternalLifecycleTransition(taskId, action, options = {}) {
   return null;
 }
 
+async function persistTaskStatusForExecution(adapter, taskId, nextStatus, source) {
+  if (!taskId || !nextStatus || !adapter) return null;
+  const normalized = String(nextStatus || "").trim();
+  if (!normalized) return null;
+  let updated = null;
+  if (typeof adapter.updateTaskStatus === "function") {
+    updated = await adapter.updateTaskStatus(taskId, normalized, { source });
+  } else if (typeof adapter.updateTask === "function") {
+    updated = await adapter.updateTask(taskId, { status: normalized });
+  }
+  return withTaskMetadataTopLevel(updated);
+}
+
+async function persistTaskExecutionMeta(adapter, taskId, executionPatch = {}) {
+  if (!taskId || !adapter || typeof adapter.updateTask !== "function") return null;
+  const current = typeof adapter.getTask === "function"
+    ? await adapter.getTask(taskId).catch(() => null)
+    : null;
+  const currentMeta = current?.meta && typeof current.meta === "object" ? current.meta : {};
+  const currentExecution = currentMeta.execution && typeof currentMeta.execution === "object"
+    ? currentMeta.execution
+    : {};
+  const nextExecution = {
+    ...currentExecution,
+    ...executionPatch,
+  };
+  if (nextExecution.queueState == null) delete nextExecution.queueState;
+  return withTaskMetadataTopLevel(await adapter.updateTask(taskId, {
+    meta: {
+      ...currentMeta,
+      execution: nextExecution,
+    },
+  }));
+}
+
+function resolveFallbackStatusAfterFailedDispatch(previousStatus, startDispatch) {
+  if (startDispatch?.reason === "no_free_slots") return "queued";
+  const previous = String(previousStatus || "").trim();
+  return previous || "todo";
+}
+
+async function reconcileTaskAfterDispatchAttempt({
+  adapter,
+  taskId,
+  previousStatus,
+  requestedStatus,
+  lifecycleAction,
+  startDispatch,
+  source,
+}) {
+  const action = normalizeLifecycleAction(lifecycleAction);
+  if (action !== "start" && action !== "resume") return null;
+  const requested = normalizeTaskStatusKey(requestedStatus);
+  if (requested !== "inprogress") return null;
+  const targetStatus = startDispatch?.started
+    ? "inprogress"
+    : resolveFallbackStatusAfterFailedDispatch(previousStatus, startDispatch);
+  return persistTaskStatusForExecution(adapter, taskId, targetStatus, source);
+}
+
+function buildTaskRuntimeSnapshot(task) {
+  const runtimeExecutor = uiDeps.getInternalExecutor?.() || null;
+  const status = runtimeExecutor?.getStatus?.() || {};
+  const activeSlots = Array.isArray(status?.slots) ? status.slots : [];
+  const taskId = String(task?.id || task?.taskId || "").trim();
+  const slot = taskId
+    ? activeSlots.find((entry) => String(entry?.taskId || entry?.task_id || "").trim() === taskId)
+    : null;
+  const normalizedStatus = normalizeTaskStatusKey(task?.status);
+  const queuedFlag = task?.meta?.execution?.queued === true
+    || normalizeTaskStatusKey(task?.meta?.execution?.queueState) === "queued";
+  if (slot) {
+    return {
+      state: "running",
+      isLive: true,
+      taskId,
+      taskStatus: task?.status || null,
+      statusLabel: "Live execution",
+      slot: {
+        taskId,
+        branch: slot?.branch || slot?.branchName || null,
+        sdk: slot?.sdk || slot?.executor || null,
+        model: slot?.model || null,
+        startedAt: slot?.startedAt || slot?.started_at || null,
+        completedCount: slot?.completedCount || 0,
+      },
+      executor: {
+        activeSlots: Number(status?.activeSlots || activeSlots.length || 0),
+        maxParallel: Number(status?.maxParallel || 0),
+        paused: runtimeExecutor?.isPaused?.() === true,
+      },
+    };
+  }
+  if (queuedFlag || normalizedStatus === "queued") {
+    return {
+      state: "queued",
+      isLive: false,
+      taskId,
+      taskStatus: task?.status || null,
+      statusLabel: "Queued for execution",
+      reason: "no_free_slots",
+    };
+  }
+  if (normalizedStatus === "inprogress") {
+    return {
+      state: "pending",
+      isLive: false,
+      taskId,
+      taskStatus: task?.status || null,
+      statusLabel: "No live execution detected",
+      reason: "no_active_executor_slot",
+    };
+  }
+  if (normalizedStatus === "inreview") {
+    return {
+      state: "review",
+      isLive: false,
+      taskId,
+      taskStatus: task?.status || null,
+      statusLabel: "Awaiting review",
+    };
+  }
+  return {
+    state: "idle",
+    isLive: false,
+    taskId,
+    taskStatus: task?.status || null,
+    statusLabel: "No active execution",
+  };
+}
+
+function withTaskRuntimeSnapshot(task) {
+  if (!task || typeof task !== "object") return task;
+  const runtimeSnapshot = buildTaskRuntimeSnapshot(task);
+  return {
+    ...task,
+    runtimeSnapshot,
+    meta: {
+      ...(task.meta || {}),
+      runtimeSnapshot,
+    },
+  };
+}
+
 async function maybeStartTaskFromLifecycleAction({
   taskId,
   updatedTask,
@@ -6848,14 +7060,13 @@ async function resolveLogPath(logType, query) {
     return resolvePreferredSystemLogPath();
   }
   if (logType === "agent") {
+    const matches = await listAgentLogFiles(query, 1);
+    if (matches.length > 0) {
+      return resolve(matches[0].source, matches[0].name);
+    }
     const agentLogsDir = await resolveAgentLogsDir();
     const files = await readdir(agentLogsDir).catch(() => []);
-    let candidates = files.filter((f) => f.endsWith(".log")).sort().reverse();
-    if (query) {
-      const q = query.toLowerCase();
-      const filtered = candidates.filter((f) => f.toLowerCase().includes(q));
-      if (filtered.length) candidates = filtered;
-    }
+    const candidates = files.filter((f) => f.endsWith(".log")).sort().reverse();
     return candidates.length ? resolve(agentLogsDir, candidates[0]) : null;
   }
   return null;
@@ -7884,6 +8095,13 @@ function buildTaskMetadataPatch(input = {}) {
     }
   }
 
+  if (hasOwn(input, "type")) {
+    const type = normalizeTaskTypeInput(input?.type);
+    if (type) {
+      topLevel.type = type;
+    }
+  }
+
   if (hasOwn(input, "epicId")) {
     const epicId = normalizeOptionalStringInput(input?.epicId);
     if (epicId) {
@@ -7919,6 +8137,13 @@ function buildTaskMetadataPatch(input = {}) {
   return { topLevel, meta };
 }
 
+const TASK_TYPE_VALUES = new Set(["epic", "task", "subtask"]);
+
+function normalizeTaskTypeInput(input) {
+  const normalized = String(input ?? "").trim().toLowerCase();
+  return TASK_TYPE_VALUES.has(normalized) ? normalized : null;
+}
+
 const SPRINT_EXECUTION_MODES = new Set(["sequential", "parallel"]);
 
 function normalizeSprintExecutionMode(input) {
@@ -8259,11 +8484,40 @@ async function listAgentLogFiles(query = "", limit = 60) {
   const entries = [];
   const agentLogsDir = await resolveAgentLogsDir();
   const files = await readdir(agentLogsDir).catch(() => []);
+  const normalizedQuery = String(query || "").trim().toLowerCase();
+  const queryTerms = Array.from(new Set([
+    normalizedQuery,
+    ...normalizedQuery
+      .split(/[^a-z0-9]+/i)
+      .map((part) => part.trim())
+      .filter((part) => part.length >= 3),
+  ].filter(Boolean)));
+
+  const scoreAgentLogMatch = (name, lines = []) => {
+    if (!queryTerms.length) return 0;
+    const fileName = String(name || "").toLowerCase();
+    const joined = lines.join("\n").toLowerCase();
+    let score = 0;
+    for (const term of queryTerms) {
+      if (fileName.includes(term)) score += 120;
+      if (joined.includes(term)) score += 80;
+    }
+    if (joined.includes("task id:")) score += 8;
+    if (/(error|warn|failed|exception|timeout|anomal)/i.test(joined)) score += 6;
+    return score;
+  };
+
   for (const name of files) {
     if (!name.endsWith(".log")) continue;
-    if (query && !name.toLowerCase().includes(query.toLowerCase())) continue;
     try {
-      const info = await stat(resolve(agentLogsDir, name));
+      const filePath = resolve(agentLogsDir, name);
+      const info = await stat(filePath);
+      let score = 0;
+      if (queryTerms.length) {
+        const sample = await tailFile(filePath, 160, 250_000).catch(() => ({ lines: [] }));
+        score = scoreAgentLogMatch(name, sample?.lines || []);
+        if (score <= 0) continue;
+      }
       entries.push({
         name,
         source: agentLogsDir,
@@ -8271,15 +8525,115 @@ async function listAgentLogFiles(query = "", limit = 60) {
         mtime:
           info.mtime?.toISOString?.() || new Date(info.mtime).toISOString(),
         mtimeMs: info.mtimeMs,
+        score,
       });
     } catch {
       // ignore
     }
   }
-  entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  entries.sort((a, b) => (b.score || 0) - (a.score || 0) || b.mtimeMs - a.mtimeMs);
   return entries.slice(0, limit);
 }
 
+function buildLogQueryTerms(query = "") {
+  const normalized = String(query || "").trim().toLowerCase();
+  if (!normalized) return [];
+  return Array.from(new Set([
+    normalized,
+    ...normalized
+      .split(/[^a-z0-9]+/i)
+      .map((part) => part.trim())
+      .filter((part) => part.length >= 3),
+  ].filter(Boolean)));
+}
+
+function isHighSignalLogLine(line = "") {
+  return /(error|warn|failed|exception|timeout|anomal|retry|blocked|fatal)/i.test(String(line || ""));
+}
+
+function filterRelevantLogLines(lines = [], query = "", limit = 200) {
+  const sourceLines = Array.isArray(lines)
+    ? lines.map((line) => String(line || "")).filter(Boolean)
+    : [];
+  if (!sourceLines.length) return [];
+
+  const terms = buildLogQueryTerms(query);
+  if (!terms.length) return sourceLines.slice(-limit);
+
+  const picked = new Set();
+  const addWithContext = (index, radius = 1) => {
+    for (let cursor = Math.max(0, index - radius); cursor <= Math.min(sourceLines.length - 1, index + radius); cursor += 1) {
+      picked.add(cursor);
+    }
+  };
+
+  sourceLines.forEach((line, index) => {
+    const lower = line.toLowerCase();
+    const termHit = terms.some((term) => lower.includes(term));
+    if (termHit) {
+      addWithContext(index, isHighSignalLogLine(line) ? 2 : 1);
+      return;
+    }
+    if (isHighSignalLogLine(line)) {
+      addWithContext(index, 1);
+    }
+  });
+
+  if (!picked.size) {
+    return sourceLines.slice(-limit);
+  }
+
+  const filtered = [...picked]
+    .sort((a, b) => a - b)
+    .map((index) => sourceLines[index]);
+  return filtered.slice(-limit);
+}
+
+async function resolveSessionWorktreePath(session) {
+  if (!session || typeof session !== "object") return null;
+  const directCandidates = [
+    session?.metadata?.worktreePath,
+    session?.metadata?.workspaceDir,
+    session?.metadata?.workspacePath,
+    session?.metadata?.cwd,
+  ]
+    .map((value) => String(value || "").trim())
+    .filter(Boolean);
+  for (const candidate of directCandidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  const branchHints = [
+    session?.metadata?.branch,
+    session?.metadata?.branchName,
+    session?.branch,
+  ]
+    .map((value) => String(value || "").trim().replace(/^refs\/heads\//, ""))
+    .filter(Boolean);
+  const taskHints = [session?.taskId, session?.id]
+    .map((value) => String(value || "").trim().toLowerCase())
+    .filter(Boolean);
+
+  try {
+    const active = await listActiveWorktrees(repoRoot);
+    const matched = (active || []).find((worktree) => {
+      const worktreePath = String(worktree?.path || "").trim();
+      const worktreeTaskKey = String(worktree?.taskKey || "").trim().toLowerCase();
+      const worktreeBranch = String(worktree?.branch || "")
+        .trim()
+        .replace(/^refs\/heads\//, "");
+      if (worktreePath && directCandidates.includes(worktreePath)) return true;
+      if (worktreeTaskKey && taskHints.includes(worktreeTaskKey)) return true;
+      return branchHints.some((hint) =>
+        hint && (worktreeBranch === hint || worktreeBranch.endsWith(`/${hint}`)),
+      );
+    });
+    return matched?.path || null;
+  } catch {
+    return null;
+  }
+}
+
 async function ensurePresenceLoaded() {
   const loaded = await loadWorkspaceRegistry().catch(() => null);
   const registry = loaded?.registry || loaded || null;
@@ -8608,6 +8962,12 @@ async function handleApi(req, res, url) {
           task.repository || task.meta?.repository || "",
         ).trim().toLowerCase();
         if (workspaceFilter && taskWorkspace !== workspaceFilter) {
+          // Backward compatibility: many legacy internal-store tasks predate
+          // workspace stamping and should remain visible in the active
+          // workspace board instead of being filtered out.
+          if (!taskWorkspaceRaw) {
+            return true;
+          }
           const taskWorkspacePath = normalizeCandidatePath(taskWorkspaceRaw);
           const workspaceMatchByPath =
             Boolean(taskWorkspacePath) &&
@@ -8647,9 +9007,10 @@ async function handleApi(req, res, url) {
       const start = page * pageSize;
       const slice = filtered.slice(start, start + pageSize);
       const enriched = await applySharedStateToTasks(slice);
+      const withRuntime = enriched.map((task) => withTaskRuntimeSnapshot(task));
       jsonResponse(res, 200, {
         ok: true,
-        data: enriched,
+        data: withRuntime,
         page,
         pageSize,
         total,
@@ -8675,7 +9036,7 @@ async function handleApi(req, res, url) {
       const adapter = getKanbanAdapter();
       const task = await adapter.getTask(taskId);
       const enriched = await applySharedStateToTasks(task ? [task] : []);
-      const detailTask = enriched[0] || null;
+      let detailTask = enriched[0] || null;
       if (detailTask) {
         const workflowRuns = await collectWorkflowRunsForTask(detailTask.id, url, 40);
         const mergedWorkflowRuns = mergeTaskWorkflowRuns(detailTask.workflowRuns, workflowRuns, 80);
@@ -8696,6 +9057,7 @@ async function handleApi(req, res, url) {
         };
         if (sprintDag) detailTask.sprintDag = sprintDag.data;
         if (globalDag) detailTask.dagOfDags = globalDag.data;
+        detailTask = withTaskRuntimeSnapshot(detailTask);
       }
       jsonResponse(res, 200, { ok: true, data: detailTask });
     } catch (err) {
@@ -9053,6 +9415,55 @@ async function handleApi(req, res, url) {
     }
     return;
   }
+  if (path === "/api/tasks/epic-dependencies" && req.method === "GET") {
+    try {
+      const listed = await listEpicDependenciesForApi();
+      if (!listed.ok) {
+        jsonResponse(res, 501, { ok: false, error: "Epic dependency APIs are unavailable." });
+        return;
+      }
+      jsonResponse(res, 200, { ok: true, source: listed.source, data: listed.data });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
+  if (path === "/api/tasks/epic-dependencies" && req.method === "PUT") {
+    try {
+      const body = await readJsonBody(req);
+      const epicId = String(body?.epicId || body?.id || "").trim();
+      const dependencies = Array.isArray(body?.dependencies)
+        ? body.dependencies
+        : Array.isArray(body?.dependsOn)
+          ? body.dependsOn
+          : [];
+      if (!epicId) {
+        jsonResponse(res, 400, { ok: false, error: "epicId required" });
+        return;
+      }
+      const updated = await setEpicDependenciesForApi({ epicId, dependencies });
+      if (!updated.ok) {
+        jsonResponse(res, updated.status || 400, { ok: false, error: updated.error || "Failed to update epic dependencies" });
+        return;
+      }
+      const globalDag = await getGlobalDagData();
+      jsonResponse(res, 200, {
+        ok: true,
+        source: updated.source,
+        data: updated.data,
+        dag: globalDag?.data || null,
+      });
+      broadcastUiEvent(["tasks", "overview"], "invalidate", {
+        reason: "epic-dependencies-updated",
+        epicId,
+      });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
   if (path === "/api/tasks/start") {
     try {
       const body = await readJsonBody(req);
@@ -9102,25 +9513,12 @@ async function handleApi(req, res, url) {
       const freeSlots =
         (status.maxParallel || 0) - (status.activeSlots || 0);
 
-      try {
-        if (typeof adapter.updateTaskStatus === "function") {
-          await adapter.updateTaskStatus(taskId, "inprogress", { source: "api.tasks.start" });
-        } else if (typeof adapter.updateTask === "function") {
-          await adapter.updateTask(taskId, { status: "inprogress" });
-        }
-        applyInternalLifecycleTransition(taskId, "start", {
-          source: "api.tasks.start",
-          actor: "ui",
-          force: forceStart || manualOverride,
-          reason: "manual start",
-        });
-      } catch (err) {
-        console.warn(
-          `[telegram-ui] failed to mark task ${taskId} inprogress: ${err.message}`,
-        );
-      }
-
       if (freeSlots <= 0) {
+        const queuedTask = await persistTaskExecutionMeta(adapter, taskId, {
+          queued: true,
+          queueState: "queued",
+          requestedAt: new Date().toISOString(),
+        });
         jsonResponse(res, 202, {
           ok: true,
           taskId,
@@ -9128,6 +9526,7 @@ async function handleApi(req, res, url) {
           started: false,
           reason: "No free slots",
           canStart,
+          data: withTaskRuntimeSnapshot(queuedTask || task),
         });
         broadcastUiEvent(
           ["tasks", "overview", "executor", "agents"],
@@ -9139,8 +9538,27 @@ async function handleApi(req, res, url) {
         );
         return;
       }
+      let startedTask = task;
+      try {
+        startedTask = await persistTaskStatusForExecution(adapter, taskId, "inprogress", "api.tasks.start") || task;
+        startedTask = await persistTaskExecutionMeta(adapter, taskId, {
+          queued: false,
+          queueState: null,
+        }) || startedTask;
+        applyInternalLifecycleTransition(taskId, "start", {
+          source: "api.tasks.start",
+          actor: "ui",
+          force: forceStart || manualOverride,
+          reason: "manual start",
+        });
+      } catch (err) {
+        console.warn(
+          `[telegram-ui] failed to mark task ${taskId} inprogress: ${err.message}`,
+        );
+      }
+
       const wasPaused = executor.isPaused?.();
-      executor.executeTask(task, {
+      executor.executeTask(startedTask, {
         ...(sdk ? { sdk } : {}),
         ...(model ? { model } : {}),
         force: forceStart || manualOverride,
@@ -9148,6 +9566,16 @@ async function handleApi(req, res, url) {
         console.warn(
           `[telegram-ui] failed to execute task ${taskId}: ${error.message}`,
         );
+        void persistTaskStatusForExecution(
+          adapter,
+          taskId,
+          resolveFallbackStatusAfterFailedDispatch(task?.status, { started: false }),
+          "api.tasks.start.failed",
+        );
+        broadcastUiEvent(["tasks", "overview", "executor", "agents"], "invalidate", {
+          reason: "task-start-failed",
+          taskId,
+        });
       });
       jsonResponse(res, 200, {
         ok: true,
@@ -9156,6 +9584,7 @@ async function handleApi(req, res, url) {
         started: true,
         wasPaused,
         canStart,
+        data: withTaskRuntimeSnapshot(startedTask),
       });
       broadcastUiEvent(
         ["tasks", "overview", "executor", "agents"],
@@ -9253,6 +9682,17 @@ async function handleApi(req, res, url) {
         forceStart,
         manualOverride,
       });
+      const reconciled = await reconcileTaskAfterDispatchAttempt({
+        adapter,
+        taskId,
+        previousStatus: previousTask?.status || null,
+        requestedStatus: nextStatus,
+        lifecycleAction,
+        startDispatch,
+        source: "api.tasks.update",
+      });
+      const responseTask = withTaskRuntimeSnapshot(reconciled || updated);
+      const responseStatus = responseTask?.status || nextStatus;
       if (body?.pauseExecution === true && lifecycleAction === "pause" && executor && typeof executor.abortTask === "function") {
         executor.abortTask(taskId, "task_lifecycle_pause");
       }
@@ -9269,19 +9709,19 @@ async function handleApi(req, res, url) {
       });
       jsonResponse(res, 200, {
         ok: true,
-        data: updated,
+        data: responseTask,
         restart,
         lifecycle: {
           action: lifecycleAction,
           previousStatus: previousTask?.status || null,
-          nextStatus,
+          nextStatus: responseStatus,
           startDispatch,
         },
       });
       broadcastUiEvent(["tasks", "overview"], "invalidate", {
         reason: "task-updated",
         taskId,
-        status: nextStatus,
+        status: responseStatus,
       });
       if (restart?.started || startDispatch?.started) {
         broadcastUiEvent(["tasks", "overview", "executor", "agents"], "invalidate", {
@@ -9377,6 +9817,17 @@ async function handleApi(req, res, url) {
         forceStart,
         manualOverride,
       });
+      const reconciled = await reconcileTaskAfterDispatchAttempt({
+        adapter,
+        taskId,
+        previousStatus: previousTask?.status || null,
+        requestedStatus: nextStatus,
+        lifecycleAction,
+        startDispatch,
+        source: "api.tasks.edit",
+      });
+      const responseTask = withTaskRuntimeSnapshot(reconciled || updated);
+      const responseStatus = responseTask?.status || nextStatus;
       if (body?.pauseExecution === true && lifecycleAction === "pause" && executor && typeof executor.abortTask === "function") {
         executor.abortTask(taskId, "task_lifecycle_pause");
       }
@@ -9393,19 +9844,19 @@ async function handleApi(req, res, url) {
       });
       jsonResponse(res, 200, {
         ok: true,
-        data: updated,
+        data: responseTask,
         restart,
         lifecycle: {
           action: lifecycleAction,
           previousStatus: previousTask?.status || null,
-          nextStatus,
+          nextStatus: responseStatus,
           startDispatch,
         },
       });
       broadcastUiEvent(["tasks", "overview"], "invalidate", {
         reason: "task-edited",
         taskId,
-        status: nextStatus,
+        status: responseStatus,
       });
       if (restart?.started || startDispatch?.started) {
         broadcastUiEvent(["tasks", "overview", "executor", "agents"], "invalidate", {
@@ -11034,8 +11485,20 @@ async function handleApi(req, res, url) {
         jsonResponse(res, 200, { ok: true, data: null });
         return;
       }
-      const tail = await tailFile(filePath, lines);
-      jsonResponse(res, 200, { ok: true, data: { file: fileName, content: tail } });
+      const tail = await tailFile(filePath, Math.max(lines * 4, 240));
+      const filteredLines = filterRelevantLogLines(tail?.lines || [], query || fileName, lines);
+      const contentLines = filteredLines.length ? filteredLines : (tail?.lines || []).slice(-lines);
+      jsonResponse(res, 200, {
+        ok: true,
+        data: {
+          file: fileName,
+          content: contentLines.join("\n"),
+          lines: contentLines,
+          mode: filteredLines.length ? "focused" : "tail",
+          totalLines: Array.isArray(tail?.lines) ? tail.lines.length : 0,
+          truncated: tail?.truncated === true,
+        },
+      });
     } catch (err) {
       jsonResponse(res, 200, { ok: true, data: null });
     }
@@ -13421,7 +13884,7 @@ async function handleApi(req, res, url) {
           });
           return;
         }
-        const worktreePath = session.metadata?.worktreePath;
+        const worktreePath = await resolveSessionWorktreePath(session);
         if (!worktreePath || !existsSync(worktreePath)) {
           jsonResponse(res, 200, { ok: true, diff: { files: [], totalFiles: 0, totalAdditions: 0, totalDeletions: 0, formatted: "(no worktree)" }, summary: "(no worktree)", commits: [] });
           return;