bosun 0.33.2 → 0.33.3

package/.env.example

@@ -979,6 +979,11 @@ COPILOT_CLOUD_DISABLED=true
 # ─── Merge Strategy / Conflict Resolution ────────────────────────────────────
 # Merge strategy mode: "smart" or "smart+codexsdk" (enables Codex conflict resolution)
 # MERGE_STRATEGY_MODE=smart
+# Flow primary mode (default: true). When enabled, merge actions are gated by
+# Flow sequencing rules instead of immediate merge-strategy execution.
+# BOSUN_FLOW_PRIMARY=true
+# Require review approval before any merge action can be enabled (default: true).
+# BOSUN_FLOW_REQUIRE_REVIEW=true
 # Codex conflict resolution timeout in ms
 # MERGE_CONFLICT_RESOLUTION_TIMEOUT_MS=600000
 

package/README.md

@@ -69,6 +69,7 @@ Key references:
 - [GitHub Projects v2 monitoring](_docs/GITHUB_PROJECTS_V2_MONITORING.md)
 - [GitHub Projects v2 checklist](_docs/GITHUB_PROJECTS_V2_IMPLEMENTATION_CHECKLIST.md)
 - [Jira integration](_docs/JIRA_INTEGRATION.md)
+- [Workflows](_docs/WORKFLOWS.md)
 - [Agent logging quickstart](docs/agent-logging-quickstart.md)
 - [Agent logging design](docs/agent-work-logging-design.md)
 - [Agent logging summary](docs/AGENT_LOGGING_SUMMARY.md)

package/merge-strategy.mjs

@@ -607,6 +607,8 @@ export function resetMergeStrategyDedup() {
  * @param {number}        [opts.timeoutMs]  Timeout for agent operations (default: 15 min)
  * @param {number}        [opts.maxRetries] Max retries for re_attempt (default: 2)
  * @param {object}        [opts.promptTemplates] Optional prompt template overrides
+ * @param {function}      [opts.canEnableMerge] Optional async gate for merge action.
+ *   Signature: ({ decision, ctx }) => Promise<{ allowed: boolean, reason?: string }>
  * @returns {Promise<ExecutionResult>}
  */
 export async function executeDecision(decision, ctx, opts = {}) {
@@ -616,6 +618,7 @@ export async function executeDecision(decision, ctx, opts = {}) {
     timeoutMs = 15 * 60 * 1000,
     maxRetries = 2,
     promptTemplates = {},
+    canEnableMerge,
   } = opts;
 
   const tag = `merge-exec(${ctx.shortId})`;
@@ -648,7 +651,11 @@ export async function executeDecision(decision, ctx, opts = {}) {
         });
 
       case "merge_after_ci_pass":
-        return await executeMergeAction(decision, ctx, { tag, onTelegram });
+        return await executeMergeAction(decision, ctx, {
+          tag,
+          onTelegram,
+          canEnableMerge,
+        });
 
       case "close_pr":
         return await executeCloseAction(decision, ctx, { tag, onTelegram });
@@ -988,7 +995,39 @@ function buildReAttemptPrompt(ctx, reason, promptTemplate = "") {
  * Enable auto-merge for the PR via `gh pr merge --auto --squash`.
  */
 async function executeMergeAction(decision, ctx, execOpts) {
-  const { tag, onTelegram } = execOpts;
+  const { tag, onTelegram, canEnableMerge } = execOpts;
+
+  if (typeof canEnableMerge === "function") {
+    try {
+      const gate = await canEnableMerge({ decision, ctx });
+      if (gate && gate.allowed === false) {
+        const reason = String(gate.reason || "merge_gate_blocked");
+        console.warn(
+          `[${tag}] merge_after_ci_pass blocked by merge gate: ${reason}`,
+        );
+        if (onTelegram) {
+          onTelegram(
+            `⛔ Merge blocked for ${ctx.taskTitle || `PR #${ctx.prNumber || "unknown"}`}: ${reason}`,
+          );
+        }
+        return {
+          executed: false,
+          action: "merge_after_ci_pass",
+          success: false,
+          error: `FLOW_REVIEW_GATE:${reason}`,
+        };
+      }
+    } catch (err) {
+      const msg = err?.message || String(err || "merge gate error");
+      console.warn(`[${tag}] merge gate threw: ${msg}`);
+      return {
+        executed: false,
+        action: "merge_after_ci_pass",
+        success: false,
+        error: `FLOW_REVIEW_GATE_ERROR:${msg}`,
+      };
+    }
+  }
 
   if (!ctx.prNumber) {
     console.warn(`[${tag}] merge_after_ci_pass but no PR number`);

package/monitor.mjs

@@ -730,6 +730,22 @@ function isReviewAgentEnabled() {
   return true;
 }
 
+function isFlowPrimaryEnabled() {
+  const explicit = process.env.BOSUN_FLOW_PRIMARY;
+  if (explicit !== undefined && String(explicit).trim() !== "") {
+    return !isFalsyFlag(explicit);
+  }
+  return !isFalsyFlag(flowPrimaryDefault);
+}
+
+function isFlowReviewGateEnabled() {
+  const explicit = process.env.BOSUN_FLOW_REQUIRE_REVIEW;
+  if (explicit !== undefined && String(explicit).trim() !== "") {
+    return !isFalsyFlag(explicit);
+  }
+  return !isFalsyFlag(flowRequireReviewDefault);
+}
+
 function isMonitorMonitorEnabled() {
   if (process.env.VITEST) return false;
   if (!isDevMode()) return false;
@@ -968,6 +984,8 @@ const codexAnalyzeMergeStrategy =
 const mergeStrategyMode = String(
   process.env.MERGE_STRATEGY_MODE || "smart",
 ).toLowerCase();
+const flowPrimaryDefault = "true";
+const flowRequireReviewDefault = "true";
 const codexResolveConflictsEnabled =
   agentPoolEnabled &&
   (process.env.CODEX_RESOLVE_CONFLICTS || "true").toLowerCase() !== "false";
@@ -4784,7 +4802,16 @@ async function checkMergedPRsAndUpdateTasks() {
         (c) => c.branch && mergedBranchCache.has(c.branch),
       );
       if (knownBranch) {
+        const canFinalize = await shouldFinalizeMergedTask(task, {
+          branch: knownBranch.branch,
+          prNumber: knownBranch.prNumber,
+          reason: "known_merged_branch",
+        });
+        if (!canFinalize) {
+          continue;
+        }
         mergedTaskCache.add(task.id);
+        pendingMergeStrategyByTask.delete(String(task.id || "").trim());
         // Cache all branches for this task
         for (const c of candidates) {
           if (c.branch) mergedBranchCache.add(c.branch);
@@ -4831,9 +4858,19 @@ async function checkMergedPRsAndUpdateTasks() {
             console.log(
               `[monitor] Task "${task.title}" (${task.id.substring(0, 8)}...) has merged PR #${cand.prNumber}, updating to done [confidence=${confidence.confidence}, ${confidence.reason}]`,
             );
+            const canFinalize = await shouldFinalizeMergedTask(task, {
+              branch: cand.branch,
+              prNumber: cand.prNumber,
+              reason: "merged_pr_detected",
+            });
+            if (!canFinalize) {
+              resolved = true;
+              break;
+            }
             const success = await updateTaskStatus(task.id, "done");
             movedCount++;
             mergedTaskCache.add(task.id);
+            pendingMergeStrategyByTask.delete(String(task.id || "").trim());
             for (const c of candidates) {
               if (c.branch) mergedBranchCache.add(c.branch);
             }
@@ -4890,9 +4927,19 @@ async function checkMergedPRsAndUpdateTasks() {
           console.log(
             `[monitor] Task "${task.title}" (${task.id.substring(0, 8)}...) has merged branch ${cand.branch}, updating to done`,
           );
+          const canFinalize = await shouldFinalizeMergedTask(task, {
+            branch: cand.branch,
+            prNumber: cand.prNumber,
+            reason: "merged_branch_detected",
+          });
+          if (!canFinalize) {
+            resolved = true;
+            break;
+          }
           const success = await updateTaskStatus(task.id, "done");
           movedCount++;
           mergedTaskCache.add(task.id);
+          pendingMergeStrategyByTask.delete(String(task.id || "").trim());
           for (const c of candidates) {
             if (c.branch) mergedBranchCache.add(c.branch);
           }
@@ -6064,6 +6111,137 @@ async function checkAndMergeDependabotPRs() {
 
 // ── Merge Strategy Analysis ─────────────────────────────────────────────────
 
+function getReviewGateSnapshot(taskId) {
+  const id = String(taskId || "").trim();
+  if (!id) return null;
+
+  const runtime = reviewGateResults.get(id);
+  if (runtime) {
+    return {
+      approved: runtime.approved === true,
+      reviewedAt: runtime.reviewedAt || null,
+      source: "runtime",
+    };
+  }
+
+  try {
+    const task = getInternalTask(id);
+    if (!task) return null;
+    return {
+      approved: task.reviewStatus === "approved",
+      reviewedAt: task.reviewedAt || null,
+      source: "task-store",
+    };
+  } catch {
+    return null;
+  }
+}
+
+function isTaskReviewApprovedForFlow(taskId) {
+  const snapshot = getReviewGateSnapshot(taskId);
+  return snapshot?.approved === true;
+}
+
+function rememberPendingMergeStrategy(ctx, reason = "review_pending") {
+  const taskId = String(ctx?.taskId || "").trim();
+  if (!taskId) return false;
+  pendingMergeStrategyByTask.set(taskId, {
+    ...ctx,
+    _flowDeferredAt: new Date().toISOString(),
+    _flowDeferredReason: reason,
+  });
+  return true;
+}
+
+function dequeuePendingMergeStrategy(taskId) {
+  const id = String(taskId || "").trim();
+  if (!id) return null;
+  const ctx = pendingMergeStrategyByTask.get(id) || null;
+  if (ctx) pendingMergeStrategyByTask.delete(id);
+  return ctx;
+}
+
+async function queueFlowReview(taskId, ctx, reason = "") {
+  if (!reviewAgent) return false;
+  const id = String(taskId || "").trim();
+  if (!id) return false;
+  try {
+    const prUrl =
+      ctx?.prUrl ||
+      (ctx?.prNumber ? `${repoUrlBase}/pull/${ctx.prNumber}` : "");
+    await reviewAgent.queueReview({
+      id,
+      title: ctx?.taskTitle || id,
+      branchName: ctx?.branch || "",
+      prUrl,
+      description: ctx?.taskDescription || "",
+      taskContext: reason ? `Flow gate reason: ${reason}` : "",
+      worktreePath: ctx?.worktreeDir || null,
+      sessionMessages: "",
+      diffStats: "",
+    });
+    return true;
+  } catch (err) {
+    console.warn(
+      `[flow-gate] failed to queue review for ${id}: ${err.message || err}`,
+    );
+    return false;
+  }
+}
+
+async function canEnableMergeForFlow(ctx) {
+  if (!isFlowPrimaryEnabled() || !isFlowReviewGateEnabled()) {
+    return { allowed: true };
+  }
+
+  const taskId = String(ctx?.taskId || "").trim();
+  if (!taskId) {
+    return { allowed: false, reason: "missing_task_id_for_review_gate" };
+  }
+
+  if (!isTaskReviewApprovedForFlow(taskId)) {
+    return { allowed: false, reason: "task_review_not_approved" };
+  }
+
+  return { allowed: true };
+}
+
+async function shouldFinalizeMergedTask(task, context = {}) {
+  if (!isFlowPrimaryEnabled() || !isFlowReviewGateEnabled()) {
+    return true;
+  }
+
+  const taskId = String(task?.id || "").trim();
+  if (!taskId) return false;
+  if (isTaskReviewApprovedForFlow(taskId)) return true;
+
+  const branch = context.branch || task?.branch || task?.workspace_branch || "";
+  const prNumber = context.prNumber || task?.pr_number || null;
+  const reason = context.reason || "merged_before_review";
+  console.log(
+    `[flow-gate] Task "${task?.title || taskId}" merged but review is not approved yet — holding in inreview`,
+  );
+  const currentStatus = String(task?.status || "").toLowerCase();
+  if (currentStatus && currentStatus !== "inreview") {
+    try {
+      await updateTaskStatus(taskId, "inreview");
+    } catch {
+      /* best effort */
+    }
+  }
+  await queueFlowReview(taskId, {
+    taskId,
+    taskTitle: task?.title || taskId,
+    taskDescription: task?.description || task?.body || "",
+    branch,
+    prNumber,
+    prUrl:
+      context.prUrl ||
+      (prNumber ? `${repoUrlBase}/pull/${prNumber}` : task?.pr_url || ""),
+  }, reason);
+  return false;
+}
+
 /**
  * Run the Codex-powered merge strategy analysis for a completed task.
  * This is fire-and-forget (void) — it runs async in the background and
@@ -6071,9 +6249,29 @@ async function checkAndMergeDependabotPRs() {
  *
  * @param {import("./merge-strategy.mjs").MergeContext} ctx
  */
-async function runMergeStrategyAnalysis(ctx) {
+async function runMergeStrategyAnalysis(ctx, opts = {}) {
   const tag = `merge-strategy(${ctx.shortId})`;
   try {
+    const skipFlowGate = opts?.skipFlowGate === true;
+    const flowGateEnabled = isFlowPrimaryEnabled() && isFlowReviewGateEnabled();
+    if (!skipFlowGate && flowGateEnabled) {
+      const taskId = String(ctx?.taskId || "").trim();
+      if (!taskId) {
+        console.warn(
+          `[${tag}] flow gate: missing taskId — deferring merge strategy until task mapping is available`,
+        );
+        return;
+      }
+      if (!isTaskReviewApprovedForFlow(taskId)) {
+        rememberPendingMergeStrategy(ctx, "review_pending");
+        await queueFlowReview(taskId, ctx, "merge_strategy_waiting_for_review");
+        console.log(
+          `[${tag}] flow gate: deferred until review is approved for task ${taskId}`,
+        );
+        return;
+      }
+    }
+
     const telegramFn =
       telegramToken && telegramChatId
         ? (msg) => void sendTelegramMessage(msg)
@@ -6105,6 +6303,7 @@ async function runMergeStrategyAnalysis(ctx) {
       onTelegram: telegramFn,
       timeoutMs:
         parseInt(process.env.MERGE_STRATEGY_TIMEOUT_MS, 10) || 15 * 60 * 1000,
+      canEnableMerge: ({ ctx: mergeCtx }) => canEnableMergeForFlow(mergeCtx),
       promptTemplates: {
         mergeStrategyFix: agentPrompts?.mergeStrategyFix,
         mergeStrategyReAttempt: agentPrompts?.mergeStrategyReAttempt,
@@ -6127,6 +6326,17 @@ async function runMergeStrategyAnalysis(ctx) {
 
     if (!execResult.success && execResult.error) {
       console.warn(`[${tag}] execution issue: ${execResult.error}`);
+      if (
+        String(execResult.error).startsWith("FLOW_REVIEW_GATE:") &&
+        ctx?.taskId
+      ) {
+        rememberPendingMergeStrategy(ctx, "merge_blocked_by_review_gate");
+        await queueFlowReview(
+          ctx.taskId,
+          ctx,
+          "merge_action_blocked_by_review_gate",
+        );
+      }
     }
   } catch (err) {
     console.warn(
@@ -6753,12 +6963,32 @@ async function smartPRFlow(attemptId, shortId, status) {
       }
       const merged = await isBranchMerged(attemptInfo.branch);
       if (merged) {
+        let canFinalize = true;
+        if (attemptInfo.task_id) {
+          canFinalize = await shouldFinalizeMergedTask(
+            {
+              id: attemptInfo.task_id,
+              title: attemptInfo.task_title || attemptInfo.task_id,
+              description: attemptInfo.task_description || "",
+              pr_number: attemptInfo.pr_number || null,
+              pr_url: attemptInfo.pr_url || "",
+            },
+            {
+              branch: attemptInfo.branch,
+              prNumber: attemptInfo.pr_number || null,
+              reason: "smartpr_initial_merged_branch",
+            },
+          );
+        }
         console.log(
-          `[monitor] ${tag}: branch ${attemptInfo.branch} confirmed merged — completing task`,
+          `[monitor] ${tag}: branch ${attemptInfo.branch} confirmed merged — ${canFinalize ? "completing task" : "awaiting review gate"}`,
         );
         mergedBranchCache.add(attemptInfo.branch);
-        if (attemptInfo.task_id) {
+        if (attemptInfo.task_id && canFinalize) {
           mergedTaskCache.add(attemptInfo.task_id);
+          pendingMergeStrategyByTask.delete(
+            String(attemptInfo.task_id || "").trim(),
+          );
           void updateTaskStatus(attemptInfo.task_id, "done");
         }
         await archiveAttempt(attemptId);
@@ -7134,6 +7364,7 @@ Return a short summary of what you did and any files that needed manual resoluti
       // ── Step 5b: Merge strategy analysis (Codex-powered) ─────
       if (codexAnalyzeMergeStrategy) {
         void runMergeStrategyAnalysis({
+          taskId: attempt?.task_id || attemptInfo?.task_id || null,
           attemptId,
           shortId,
           status,
@@ -7267,12 +7498,32 @@ async function resolveAndTriggerSmartPR(shortId, status) {
       // Check GitHub for a merged PR with this head branch
       const merged = await isBranchMerged(resolvedAttempt.branch);
       if (merged) {
+        let canFinalize = true;
+        if (resolvedAttempt.task_id) {
+          canFinalize = await shouldFinalizeMergedTask(
+            {
+              id: resolvedAttempt.task_id,
+              title: resolvedAttempt.task_title || resolvedAttempt.task_id,
+              description: resolvedAttempt.task_description || "",
+              pr_number: resolvedAttempt.pr_number || null,
+              pr_url: resolvedAttempt.pr_url || "",
+            },
+            {
+              branch: resolvedAttempt.branch,
+              prNumber: resolvedAttempt.pr_number || null,
+              reason: "resolve_smartpr_merged_branch",
+            },
+          );
+        }
         console.log(
-          `[monitor] smartPR(${shortId}): branch ${resolvedAttempt.branch} confirmed merged — completing task and skipping PR flow`,
+          `[monitor] smartPR(${shortId}): branch ${resolvedAttempt.branch} confirmed merged — ${canFinalize ? "completing task and skipping PR flow" : "awaiting review gate"}`,
         );
         mergedBranchCache.add(resolvedAttempt.branch);
-        if (resolvedAttempt.task_id) {
+        if (resolvedAttempt.task_id && canFinalize) {
           mergedTaskCache.add(resolvedAttempt.task_id);
+          pendingMergeStrategyByTask.delete(
+            String(resolvedAttempt.task_id || "").trim(),
+          );
           void updateTaskStatus(resolvedAttempt.task_id, "done");
         }
         await archiveAttempt(resolvedAttempt.id || shortId);
@@ -12356,6 +12607,10 @@ let agentEndpoint = null;
 let agentEventBus = null;
 /** @type {import("./review-agent.mjs").ReviewAgent|null} */
 let reviewAgent = null;
+/** @type {Map<string, import("./merge-strategy.mjs").MergeContext>} */
+const pendingMergeStrategyByTask = new Map();
+/** @type {Map<string, { approved: boolean, reviewedAt: string }>} */
+const reviewGateResults = new Map();
 /** @type {import("./sync-engine.mjs").SyncEngine|null} */
 let syncEngine = null;
 /** @type {import("./error-detector.mjs").ErrorDetector|null} */
@@ -12715,9 +12970,14 @@ if (isExecutorDisabled()) {
               : null,
           promptTemplate: agentPrompts?.reviewer,
           onReviewComplete: (taskId, result) => {
+            const normalizedTaskId = String(taskId || "").trim();
             console.log(
               `[monitor] review complete for ${taskId}: ${result?.approved ? "approved" : "changes_requested"} — prMerged: ${result?.prMerged}`,
             );
+            reviewGateResults.set(normalizedTaskId, {
+              approved: result?.approved === true,
+              reviewedAt: result?.reviewedAt || new Date().toISOString(),
+            });
             try {
               setReviewResult(taskId, {
                 approved: result?.approved ?? false,
@@ -12726,6 +12986,9 @@ if (isExecutorDisabled()) {
             } catch {
               /* best-effort */
             }
+            const pendingCtx = result?.approved
+              ? dequeuePendingMergeStrategy(normalizedTaskId)
+              : null;
 
             if (result?.approved && result?.prMerged) {
               // PR merged and reviewer happy — fully done
@@ -12747,10 +13010,27 @@ if (isExecutorDisabled()) {
               console.log(
                 `[monitor] review approved but PR not merged — ${taskId} stays inreview`,
               );
+              if (pendingCtx) {
+                console.log(
+                  `[monitor] flow gate released for ${taskId} — running deferred merge strategy`,
+                );
+                void runMergeStrategyAnalysis(
+                  {
+                    ...pendingCtx,
+                    taskId: pendingCtx.taskId || taskId,
+                  },
+                  { skipFlowGate: false },
+                );
+              }
             } else {
               console.log(
                 `[monitor] review found ${result?.issues?.length || 0} issue(s) for ${taskId} — task stays inreview`,
               );
+              if (pendingMergeStrategyByTask.has(normalizedTaskId)) {
+                console.log(
+                  `[monitor] flow gate remains active for ${taskId} — merge strategy stays deferred`,
+                );
+              }
             }
           },
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.33.2",
+  "version": "0.33.3",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache 2.0",

package/review-agent.mjs

@@ -185,9 +185,17 @@ function getPrDiff({ prUrl, branchName }) {
 function parseReviewResult(raw) {
   if (!raw || !raw.trim()) {
     return {
-      approved: true,
-      issues: [],
-      summary: "Empty agent output — auto-approved",
+      approved: false,
+      issues: [
+        {
+          severity: "major",
+          category: "broken",
+          file: "(review)",
+          line: null,
+          description: "Reviewer returned empty output; review is not complete.",
+        },
+      ],
+      summary: "Empty reviewer output",
     };
   }
 
@@ -218,11 +226,19 @@ function parseReviewResult(raw) {
     }
   }
 
-  // Couldn't parse — auto-approve with note
+  // Couldn't parse — treat as failed review to prevent unsafe auto-merge.
   return {
-    approved: true,
-    issues: [],
-    summary: "Could not parse review output — auto-approved",
+    approved: false,
+    issues: [
+      {
+        severity: "major",
+        category: "broken",
+        file: "(review)",
+        line: null,
+        description: "Could not parse reviewer output as JSON.",
+      },
+    ],
+    summary: "Could not parse reviewer output",
   };
 }
 
@@ -232,8 +248,18 @@ function parseReviewResult(raw) {
  * @returns {{ approved: boolean, issues: Array, summary: string }}
  */
 function normalizeResult(obj) {
-  const approved = obj.verdict !== "changes_requested";
+  const verdict = String(obj?.verdict || "").trim().toLowerCase();
+  const approved = verdict === "approved";
   const issues = Array.isArray(obj.issues) ? obj.issues : [];
+  if (!approved && verdict !== "changes_requested" && issues.length === 0) {
+    issues.push({
+      severity: "major",
+      category: "broken",
+      file: "(review)",
+      line: null,
+      description: `Invalid reviewer verdict "${verdict || "missing"}".`,
+    });
+  }
   const summary = typeof obj.summary === "string" ? obj.summary : "";
   return { approved, issues, summary };
 }
@@ -249,7 +275,7 @@ export class ReviewAgent {
   /** @type {Array<{ id: string, title: string, branchName: string, prUrl: string, description: string, taskContext?: string }>} */
   #queue = [];
 
-  /** @type {Set<string>} - task IDs already reviewed or in-flight */
+  /** @type {Set<string>} - task IDs queued or currently in-flight */
   #seen = new Set();
 
   #completedCount = 0;
@@ -309,7 +335,7 @@ export class ReviewAgent {
 
   /**
    * Queue a task for review.
-   * Deduplicates by task ID — same task won't be reviewed twice.
+   * Deduplicates by task ID while queued/in-flight.
    * @param {{ id: string, title: string, branchName: string, prUrl: string, description: string, taskContext?: string }} task
    */
   async queueReview(task) {
@@ -319,7 +345,7 @@ export class ReviewAgent {
     }
 
     if (this.#seen.has(task.id)) {
-      console.log(`${TAG} task ${task.id} already reviewed/queued — skipping`);
+      console.log(`${TAG} task ${task.id} already queued/in-flight — skipping`);
       return;
     }
 
@@ -412,6 +438,7 @@ export class ReviewAgent {
           })
           .finally(() => {
             this.#activeReviews.delete(task.id);
+            this.#seen.delete(task.id);
             this.#completedCount++;
             // Continue processing after slot freed
             if (this.#running && this.#queue.length > 0) {
@@ -441,12 +468,21 @@ export class ReviewAgent {
 
     if (!diff) {
       console.log(
-        `${TAG} no diff available for task ${task.id} — auto-approving`,
+        `${TAG} no diff available for task ${task.id} — marking review as changes requested`,
       );
       const result = {
-        approved: true,
-        issues: [],
-        summary: "No diff available",
+        approved: false,
+        issues: [
+          {
+            severity: "major",
+            category: "broken",
+            file: "(diff)",
+            line: null,
+            description:
+              "No diff could be loaded for this PR; cannot complete review safely.",
+          },
+        ],
+        summary: "No diff available for review",
         reviewedAt: new Date().toISOString(),
         agentOutput: "",
       };
@@ -474,7 +510,7 @@ export class ReviewAgent {
       const sdkResult = await execWithRetry(prompt, {
         taskKey: `review-${task.id}`,
         timeoutMs: this.#reviewTimeoutMs,
-        maxRetries: 0, // Reviews don't retry — approve on failure
+        maxRetries: 0, // Reviews don't retry — reject on failure
         sdk: this.#sdk,
       });
 
@@ -482,8 +518,16 @@ export class ReviewAgent {
     } catch (err) {
       console.error(`${TAG} SDK call failed for task ${task.id}:`, err.message);
       const result = {
-        approved: true,
-        issues: [],
+        approved: false,
+        issues: [
+          {
+            severity: "major",
+            category: "broken",
+            file: "(review)",
+            line: null,
+            description: `Reviewer execution failed: ${err.message}`,
+          },
+        ],
         summary: `Review failed: ${err.message}`,
         reviewedAt: new Date().toISOString(),
         agentOutput: "",

package/setup-web-server.mjs

@@ -30,7 +30,10 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 //   2. Node module resolution via createRequire — handles global install hoisting
 //   3. CDN redirect — last resort
 const _require = createRequire(import.meta.url);
-const BUNDLED_VENDOR_DIR = resolve(__dirname, "ui", "vendor");
+const uiRootPreferred = resolve(__dirname, "site", "ui");
+const uiRootFallback = resolve(__dirname, "ui");
+const uiRoot = existsSync(uiRootPreferred) ? uiRootPreferred : uiRootFallback;
+const BUNDLED_VENDOR_DIR = resolve(uiRoot, "vendor");
 
 const VENDOR_FILES = {
   "preact.js":                { specifier: "preact/dist/preact.module.js",                  cdn: "https://esm.sh/preact@10.25.4" },
@@ -997,7 +1000,6 @@ async function handleRequest(req, res) {
   }
 
   // Static file serving from ui/
-  const uiRoot = resolve(__dirname, "ui");
   let pathname = url.pathname === "/" || url.pathname === "/setup" ? "/setup.html" : url.pathname;
   const filePath = resolve(uiRoot, `.${pathname}`);
 

package/ui/components/chat-view.js

@@ -397,6 +397,7 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
     session?.status === "active" || session?.status === "running";
   const resumeLabel =
     session?.status === "archived" ? "Unarchive" : "Resume Session";
+  const safeSessionId = sessionId ? encodeURIComponent(sessionId) : "";
 
   /* Memoize the filter key list so filteredMessages memoization works properly.
      Previously a new array was created every render, breaking useMemo deps. */
@@ -630,7 +631,7 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
       for (const file of list) {
         form.append("file", file, file.name || "attachment");
       }
-      const res = await apiFetch(`/api/sessions/${sessionId}/attachments`, {
+      const res = await apiFetch(`/api/sessions/${safeSessionId}/attachments`, {
         method: "POST",
         body: form,
       });
@@ -684,7 +685,7 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
     setSending(true);
 
     try {
-      await apiFetch(`/api/sessions/${sessionId}/message`, {
+      await apiFetch(`/api/sessions/${safeSessionId}/message`, {
         method: "POST",
         body: JSON.stringify({
           content: text,
@@ -702,7 +703,7 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
 
   const handleResume = useCallback(async () => {
     try {
-      await apiFetch(`/api/sessions/${sessionId}/resume`, { method: "POST" });
+      await apiFetch(`/api/sessions/${safeSessionId}/resume`, { method: "POST" });
       showToast(
         session?.status === "archived" ? "Session unarchived" : "Session resumed",
         "success",
@@ -717,7 +718,7 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
 
   const handleArchive = useCallback(async () => {
     try {
-      await apiFetch(`/api/sessions/${sessionId}/archive`, { method: "POST" });
+      await apiFetch(`/api/sessions/${safeSessionId}/archive`, { method: "POST" });
       showToast("Session archived", "success");
       await loadSessions();
       const res = await loadSessionMessages(sessionId);

package/ui/components/diff-viewer.js

@@ -99,8 +99,9 @@ export function DiffViewer({ sessionId }) {
     let active = true;
     setLoading(true);
     setError(null);
+    const safeSessionId = encodeURIComponent(sessionId);
 
-    apiFetch(`/api/sessions/${sessionId}/diff`, { _silent: true })
+    apiFetch(`/api/sessions/${safeSessionId}/diff`, { _silent: true })
       .then((res) => {
         if (!active) return;
         setDiffData(res?.diff || null);
@@ -118,7 +119,8 @@ export function DiffViewer({ sessionId }) {
   const handleRetry = useCallback(() => {
     setError(null);
     setLoading(true);
-    apiFetch(`/api/sessions/${sessionId}/diff`, { _silent: true })
+    const safeSessionId = encodeURIComponent(sessionId);
+    apiFetch(`/api/sessions/${safeSessionId}/diff`, { _silent: true })
       .then((res) => setDiffData(res?.diff || null))
       .catch(() => setError("unavailable"))
       .finally(() => setLoading(false));

package/ui/components/kanban-board.js

@@ -10,6 +10,7 @@ import { apiFetch } from "../modules/api.js";
 import { haptic } from "../modules/telegram.js";
 import { formatRelative, truncate, cloneValue } from "../modules/utils.js";
 import { iconText, resolveIcon } from "../modules/icon-utils.js";
+import { getAgentDisplay } from "../modules/agent-display.js";
 
 const html = htm.bind(h);
 
@@ -340,6 +341,16 @@ function KanbanCard({ task, onOpen }) {
   const baseBranch = getTaskBaseBranch(task);
   const repoName = task.repo || task.repository || "";
   const issueNum = task.issueNumber || task.issue_number || (typeof task.id === "string" && /^\d+$/.test(task.id) ? task.id : null);
+  const hasAgent = Boolean(
+    task?.assignee ||
+    task?.meta?.execution?.sdk ||
+    task?.meta?.execution?.executor ||
+    task?.sdk ||
+    task?.executor ||
+    task?.agent ||
+    task?.agentName,
+  );
+  const agentDisplay = hasAgent ? getAgentDisplay(task) : null;
 
   return html`
     <div
@@ -380,7 +391,12 @@ function KanbanCard({ task, onOpen }) {
         </div>
       `}
       <div class="kanban-card-meta">
-        ${task.assignee && html`<span class="kanban-card-assignee" title=${task.assignee}>${task.assignee.split("-")[0]}</span>`}
+        ${agentDisplay && html`
+          <span
+            class="kanban-card-assignee"
+            title=${agentDisplay.label}
+          >${agentDisplay.icon}</span>
+        `}
         <span class="kanban-card-id">${typeof task.id === "string" ? truncate(task.id, 12) : task.id}</span>
         ${task.created_at && html`<span>${formatRelative(task.created_at)}</span>`}
       </div>

package/ui/components/session-list.js

@@ -23,6 +23,12 @@ let _wsListenerReady = false;
 /** Track the last filter used so createSession can reload with the same filter */
 let _lastLoadFilter = {};
 
+function sessionPath(id, action = "") {
+  const safeId = encodeURIComponent(String(id || "").trim());
+  if (!safeId) return "";
+  return action ? `/api/sessions/${safeId}/${action}` : `/api/sessions/${safeId}`;
+}
+
 /* ─── Data loaders ─── */
 export async function loadSessions(filter = {}) {
   _lastLoadFilter = filter;
@@ -38,7 +44,9 @@ export async function loadSessions(filter = {}) {
 
 export async function loadSessionMessages(id) {
   try {
-    const res = await apiFetch(`/api/sessions/${id}`, { _silent: true });
+    const url = sessionPath(id);
+    if (!url) return { ok: false, error: "invalid" };
+    const res = await apiFetch(url, { _silent: true });
     if (res?.session) {
       sessionMessages.value = res.session.messages || [];
       return { ok: true, messages: sessionMessages.value };
@@ -195,7 +203,9 @@ export async function createSession(options = {}) {
 /* ─── Session actions ─── */
 export async function archiveSession(id) {
   try {
-    await apiFetch(`/api/sessions/${id}/archive`, { method: "POST" });
+    const url = sessionPath(id, "archive");
+    if (!url) return false;
+    await apiFetch(url, { method: "POST" });
     if (selectedSessionId.value === id) selectedSessionId.value = null;
     await loadSessions(_lastLoadFilter);
     return true;
@@ -206,7 +216,9 @@ export async function archiveSession(id) {
 
 export async function deleteSession(id) {
   try {
-    await apiFetch(`/api/sessions/${id}/delete`, { method: "POST" });
+    const url = sessionPath(id, "delete");
+    if (!url) return false;
+    await apiFetch(url, { method: "POST" });
     if (selectedSessionId.value === id) selectedSessionId.value = null;
     await loadSessions(_lastLoadFilter);
     return true;
@@ -217,7 +229,9 @@ export async function deleteSession(id) {
 
 export async function resumeSession(id) {
   try {
-    await apiFetch(`/api/sessions/${id}/resume`, { method: "POST" });
+    const url = sessionPath(id, "resume");
+    if (!url) return false;
+    await apiFetch(url, { method: "POST" });
     await loadSessions(_lastLoadFilter);
     return true;
   } catch {

package/ui/modules/agent-display.js

@@ -0,0 +1,79 @@
+/* ─────────────────────────────────────────────────────────────
+ *  Agent display helpers
+ *  - Normalizes SDK/executor metadata to icons + labels
+ * ───────────────────────────────────────────────────────────── */
+import { resolveIcon } from "./icon-utils.js";
+
+const AGENT_SDKS = [
+  {
+    key: "codex",
+    label: "Codex",
+    icon: "⚡",
+    aliases: ["codex", "openai", "gpt", "o3", "o4"],
+  },
+  {
+    key: "copilot",
+    label: "Copilot",
+    icon: "🤖",
+    aliases: ["copilot", "github"],
+  },
+  {
+    key: "claude",
+    label: "Claude",
+    icon: "🧠",
+    aliases: ["claude", "anthropic"],
+  },
+];
+
+function normalize(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function resolveSdkKey(raw) {
+  const normalized = normalize(raw);
+  if (!normalized) return null;
+  for (const sdk of AGENT_SDKS) {
+    if (sdk.aliases.some((alias) => normalized.includes(alias))) {
+      return sdk.key;
+    }
+  }
+  return null;
+}
+
+function findSdk(task = {}) {
+  const execution = task?.meta?.execution || task?.execution || {};
+  const candidates = [
+    execution.sdk,
+    execution.executor,
+    task.sdk,
+    task.executor,
+    task.meta?.sdk,
+    task.meta?.executor,
+    task.assignee,
+    task.agent,
+    task.agentId,
+    task.agentName,
+  ];
+  for (const candidate of candidates) {
+    const key = resolveSdkKey(candidate);
+    if (key) return key;
+  }
+  return null;
+}
+
+export function getAgentDisplay(task = {}) {
+  const sdkKey = findSdk(task);
+  const sdk = sdkKey ? AGENT_SDKS.find((entry) => entry.key === sdkKey) : null;
+  if (sdk) {
+    return {
+      key: sdk.key,
+      label: sdk.label,
+      icon: resolveIcon(sdk.icon) || sdk.icon,
+    };
+  }
+  return {
+    key: "agent",
+    label: "Agent",
+    icon: resolveIcon("🤖") || "🤖",
+  };
+}

package/ui/styles/components.css

@@ -867,6 +867,7 @@ select.input {
   justify-content: center;
   align-items: center;
   padding: 8px 0;
+  position: relative;
 }
 
 .donut-legend {
@@ -5350,3 +5351,17 @@ select.input {
   height: 16px;
   stroke-width: 1.7;
 }
+
+.agent-inline-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  margin-right: 6px;
+  line-height: 0;
+}
+
+.agent-inline-icon svg {
+  width: 14px;
+  height: 14px;
+  stroke-width: 1.7;
+}

package/ui/styles/kanban.css

@@ -391,6 +391,11 @@ body.kanban-dragging .kanban-card {
   flex-shrink: 0;
 }
 
+.kanban-card-assignee svg {
+  width: 12px;
+  height: 12px;
+}
+
 .kanban-card-title {
   font-size: 14px;
   font-weight: 500;

package/ui/tabs/chat.js

@@ -545,12 +545,12 @@ export function ChatTab() {
         markUserMessageSent(activeAgent.value);
 
         // Use sendOrQueue for offline resilience
-        const sendFn = async (sid, msg) => {
-          await apiFetch(`/api/sessions/${sid}/message`, {
-            method: "POST",
-            body: JSON.stringify({ content: msg, mode: agentMode.value, yolo: yoloMode.peek() }),
-          });
-        };
+          const sendFn = async (sid, msg) => {
+            await apiFetch(`/api/sessions/${encodeURIComponent(sid)}/message`, {
+              method: "POST",
+              body: JSON.stringify({ content: msg, mode: agentMode.value, yolo: yoloMode.peek() }),
+            });
+          };
 
         try {
           await sendOrQueue(sessionId, content, sendFn);
@@ -576,7 +576,7 @@ export function ChatTab() {
           markUserMessageSent(activeAgent.value);
 
           try {
-            await apiFetch(`/api/sessions/${newId}/message`, {
+            await apiFetch(`/api/sessions/${encodeURIComponent(newId)}/message`, {
               method: "POST",
               body: JSON.stringify({ content, mode: agentMode.value, yolo: yoloMode.peek() }),
             });
@@ -638,10 +638,10 @@ export function ChatTab() {
   /* ── Session rename ── */
   async function saveRename(sid, newTitle) {
     try {
-      await apiFetch(`/api/sessions/${sid}/rename`, {
-        method: "POST",
-        body: JSON.stringify({ title: newTitle }),
-      });
+        await apiFetch(`/api/sessions/${encodeURIComponent(sid)}/rename`, {
+          method: "POST",
+          body: JSON.stringify({ title: newTitle }),
+        });
       loadSessions();
       showToast("Session renamed", "success");
     } catch {

package/ui/tabs/tasks.js

@@ -16,6 +16,7 @@ const html = htm.bind(h);
 import { haptic, showConfirm } from "../modules/telegram.js";
 import { apiFetch, sendCommandToChat } from "../modules/api.js";
 import { iconText, resolveIcon } from "../modules/icon-utils.js";
+import { getAgentDisplay } from "../modules/agent-display.js";
 import { signal } from "@preact/signals";
 import {
   tasksData,
@@ -786,7 +787,7 @@ export function TaskProgressModal({ task, onClose }) {
     : "var(--color-error)";
 
   const startedRelative = liveTask?.created ? formatRelative(liveTask.created) : "—";
-  const agentLabel = liveTask?.assignee || task.assignee || "Agent";
+  const agentDisplay = getAgentDisplay(liveTask || task);
   const branchLabel = liveTask?.branch || task.branch || "—";
 
   const handleCancel = async () => {
@@ -842,10 +843,13 @@ export function TaskProgressModal({ task, onClose }) {
 
       
       <div class="tp-meta-strip">
-        <div class="tp-meta-item">
-          <span class="tp-meta-label">Agent</span>
-          <span class="tp-meta-value">${agentLabel}</span>
-        </div>
+          <div class="tp-meta-item">
+            <span class="tp-meta-label">Agent</span>
+            <span class="tp-meta-value">
+              <span class="agent-inline-icon">${agentDisplay.icon}</span>
+              ${agentDisplay.label}
+            </span>
+          </div>
         <div class="tp-meta-item">
           <span class="tp-meta-label">Branch</span>
           <span class="tp-meta-value mono">${branchLabel}</span>
@@ -964,7 +968,7 @@ export function TaskReviewModal({ task, onClose, onStart }) {
 
   const prNumber = liveTask?.pr || task.pr;
   const branchLabel = liveTask?.branch || task.branch || "—";
-  const agentLabel = liveTask?.assignee || task.assignee || "Agent";
+  const agentDisplay = getAgentDisplay(liveTask || task);
   const updatedRelative = liveTask?.updated ? formatRelative(liveTask.updated) : "—";
   const reviewAttachments = normalizeTaskAttachments(liveTask || task);
 
@@ -1060,10 +1064,13 @@ export function TaskReviewModal({ task, onClose, onStart }) {
 
       
       <div class="tr-meta-grid">
-        <div class="tr-meta-item">
-          <span class="tr-meta-label">Agent</span>
-          <span class="tr-meta-value">${agentLabel}</span>
-        </div>
+          <div class="tr-meta-item">
+            <span class="tr-meta-label">Agent</span>
+            <span class="tr-meta-value">
+              <span class="agent-inline-icon">${agentDisplay.icon}</span>
+              ${agentDisplay.label}
+            </span>
+          </div>
         <div class="tr-meta-item">
           <span class="tr-meta-label">Branch</span>
           <span class="tr-meta-value mono">${branchLabel}</span>

package/ui/tabs/workflows.js

@@ -1288,6 +1288,15 @@ function NodeConfigEditor({ node, nodeTypes: types, onUpdate, onUpdateLabel, onC
 function WorkflowListView() {
   const wfs = workflows.value || [];
   const tmpls = templates.value || [];
+  const installedTemplateIds = new Set();
+  wfs.forEach((wf) => {
+    if (wf.metadata?.installedFrom) installedTemplateIds.add(wf.metadata.installedFrom);
+    installedTemplateIds.add(wf.name);
+  });
+  const availableTemplates = tmpls.filter((t) => {
+    if (installedTemplateIds.has(t.id) || installedTemplateIds.has(t.name)) return false;
+    return true;
+  });
 
   return html`
     <div style="padding: 0 4px;">
@@ -1384,25 +1393,30 @@ function WorkflowListView() {
               const newWf = { name: "New Workflow", description: "", category: "custom", enabled: true, nodes: [], edges: [], variables: {} };
               saveWorkflow(newWf).then(wf => { if (wf) { activeWorkflow.value = wf; viewMode.value = "canvas"; } });
             }}>+ Create Blank</button>
-            ${tmpls.length > 0 && html`
-              <button class="wf-btn" style="border-color: #f59e0b60; color: #f59e0b;" onClick=${() => installTemplate(tmpls[0]?.id)}>
+            ${availableTemplates.length > 0 && html`
+              <button class="wf-btn" style="border-color: #f59e0b60; color: #f59e0b;" onClick=${() => installTemplate(availableTemplates[0]?.id)}>
                 <span class="btn-icon">${resolveIcon("zap")}</span>
-                Quick Install: ${tmpls[0]?.name}
+                Quick Install: ${availableTemplates[0]?.name}
               </button>
             `}
           </div>
         </div>
       `}
 
-      <!-- Templates (grouped by category) -->
+      <!-- Templates (grouped by category, deduped against installed) -->
       <div>
         <h3 style="font-size: 14px; font-weight: 600; color: var(--color-text-secondary, #8b95a5); margin-bottom: 12px; text-transform: uppercase; letter-spacing: 0.5px;">
-          Templates (${tmpls.length})
+          Available Templates (${availableTemplates.length})${tmpls.length !== availableTemplates.length ? html` <span style="font-size: 11px; font-weight: 400; opacity: 0.6;">· ${tmpls.length - availableTemplates.length} installed</span>` : ""}
         </h3>
+        ${availableTemplates.length === 0 && html`
+          <div style="text-align: center; padding: 24px; opacity: 0.5; font-size: 13px;">
+            All templates are installed! 🎉
+          </div>
+        `}
         ${(() => {
           // Group templates by category
           const groups = {};
-          tmpls.forEach(t => {
+          availableTemplates.forEach(t => {
             const key = t.category || "custom";
             if (!groups[key]) groups[key] = { label: t.categoryLabel || key, icon: t.categoryIcon || "settings", order: t.categoryOrder || 99, items: [] };
             groups[key].items.push(t);

package/ui-server.mjs

@@ -125,7 +125,9 @@ import {
 
 const __dirname = resolve(fileURLToPath(new URL(".", import.meta.url)));
 const repoRoot = resolveRepoRoot();
-const uiRoot = resolve(__dirname, "ui");
+const uiRootPreferred = resolve(__dirname, "site", "ui");
+const uiRootFallback = resolve(__dirname, "ui");
+const uiRoot = existsSync(uiRootPreferred) ? uiRootPreferred : uiRootFallback;
 let libraryInitAttempted = false;
 
 function ensureLibraryInitialized() {
@@ -154,7 +156,7 @@ function ensureLibraryInitialized() {
 //   2. node_modules      — createRequire resolution (handles npm hoisting)
 //   3. CDN redirect      — last resort for airgap / first-run edge cases
 const _require = createRequire(import.meta.url);
-const BUNDLED_VENDOR_DIR = resolve(__dirname, "ui", "vendor");
+const BUNDLED_VENDOR_DIR = resolve(uiRoot, "vendor");
 
 function resolveVendorPath(specifier) {
   // Direct resolution first (works when package exports allow the sub-path)
@@ -248,7 +250,10 @@ async function handleVendor(req, res, url) {
 }
 const statusPath = resolve(repoRoot, ".cache", "ve-orchestrator-status.json");
 const logsDir = resolve(__dirname, "logs");
-const agentLogsDir = resolve(repoRoot, ".cache", "agent-logs");
+const agentLogsDirCandidates = [
+  resolve(__dirname, "logs", "agents"),
+  resolve(repoRoot, ".cache", "agent-logs"),
+];
 const CONFIG_SCHEMA_PATH = resolve(__dirname, "bosun.schema.json");
 const PLANNER_STATE_PATH = resolve(
   repoRoot,
@@ -2235,6 +2240,21 @@ function broadcastSessionMessage(payload) {
 
 /* ─── Log Streaming Helpers ─── */
 
+async function resolveAgentLogsDir() {
+  for (const dir of agentLogsDirCandidates) {
+    const files = await readdir(dir).catch(() => null);
+    if (files?.some((f) => f.endsWith(".log"))) return dir;
+  }
+  for (const dir of agentLogsDirCandidates) {
+    if (existsSync(dir)) return dir;
+  }
+  return agentLogsDirCandidates[0];
+}
+
+function normalizeAgentLogName(name) {
+  return basename(String(name || "")).trim();
+}
+
 /**
  * Resolve the log file path for a given logType and optional query.
  * Returns null if no matching file found.
@@ -2246,6 +2266,7 @@ async function resolveLogPath(logType, query) {
     return logFile ? resolve(logsDir, logFile) : null;
   }
   if (logType === "agent") {
+    const agentLogsDir = await resolveAgentLogsDir();
     const files = await readdir(agentLogsDir).catch(() => []);
     let candidates = files.filter((f) => f.endsWith(".log")).sort().reverse();
     if (query) {
@@ -3325,6 +3346,7 @@ function summarizeTelemetry(metrics, days) {
 
 async function listAgentLogFiles(query = "", limit = 60) {
   const entries = [];
+  const agentLogsDir = await resolveAgentLogsDir();
   const files = await readdir(agentLogsDir).catch(() => []);
   for (const name of files) {
     if (!name.endsWith(".log")) continue;
@@ -3333,6 +3355,7 @@ async function listAgentLogFiles(query = "", limit = 60) {
       const info = await stat(resolve(agentLogsDir, name));
       entries.push({
         name,
+        source: agentLogsDir,
         size: info.size,
         mtime:
           info.mtime?.toISOString?.() || new Date(info.mtime).toISOString(),
@@ -4617,7 +4640,7 @@ async function handleApi(req, res, url) {
 
   if (path === "/api/agent-logs") {
     try {
-      const file = url.searchParams.get("file");
+      const file = normalizeAgentLogName(url.searchParams.get("file"));
       const query = url.searchParams.get("query") || "";
       const lines = Math.min(
         1000,
@@ -4628,6 +4651,7 @@ async function handleApi(req, res, url) {
         jsonResponse(res, 200, { ok: true, data: files });
         return;
       }
+      const agentLogsDir = await resolveAgentLogsDir();
       const filePath = resolve(agentLogsDir, file);
       if (!filePath.startsWith(agentLogsDir)) {
         jsonResponse(res, 403, { ok: false, error: "Forbidden" });
@@ -4851,7 +4875,8 @@ async function handleApi(req, res, url) {
         return;
       }
       const latest = files[0];
-      const filePath = resolve(agentLogsDir, latest.name || latest);
+      const agentLogsDir = await resolveAgentLogsDir();
+      const filePath = resolve(agentLogsDir, normalizeAgentLogName(latest.name || latest));
       if (!filePath.startsWith(agentLogsDir) || !existsSync(filePath)) {
         jsonResponse(res, 200, { ok: true, data: null });
         return;
@@ -5417,8 +5442,9 @@ async function handleApi(req, res, url) {
       const all = engine.list();
       jsonResponse(res, 200, { ok: true, workflows: all.map(w => ({
         id: w.id, name: w.name, description: w.description, category: w.category,
-        enabled: w.enabled !== false, nodeCount: (w.nodes || []).length,
-        trigger: (w.nodes || [])[0]?.type || "manual",
+        enabled: w.enabled !== false,
+        nodeCount: Number.isFinite(w.nodeCount) ? w.nodeCount : (w.nodes || []).length,
+        trigger: w.trigger || (w.nodes || [])[0]?.type || "manual",
       })) });
     } catch (err) {
       jsonResponse(res, 500, { ok: false, error: err.message });
@@ -5530,8 +5556,7 @@ async function handleApi(req, res, url) {
       }
 
       // GET — return full workflow definition
-      const all = engine.list();
-      const wf = all.find(w => w.id === workflowId);
+      const wf = engine.get(workflowId);
       if (!wf) { jsonResponse(res, 404, { ok: false, error: "Workflow not found" }); return; }
       jsonResponse(res, 200, { ok: true, workflow: wf });
     } catch (err) {
@@ -6876,8 +6901,7 @@ export async function startTelegramUiServer(options = {}) {
     }
   }
 
-  // Start cloudflared tunnel for trusted TLS (Telegram Mini App requires valid cert)
-  if (uiServerTls) {
+    // Start cloudflared tunnel for trusted TLS (Telegram Mini App requires valid cert)
     const tUrl = await startTunnel(actualPort);
     if (tUrl) {
       console.log(`[telegram-ui] Telegram Mini App URL: ${tUrl}`);
@@ -6888,7 +6912,6 @@ export async function startTelegramUiServer(options = {}) {
         );
       }
     }
-  }
 
   return uiServer;
 }