bosun 0.42.0 → 0.42.2

package/ui/tabs/tasks.js

@@ -66,6 +66,7 @@ import {
   SkeletonCard,
   EmptyState
 } from "../components/shared.js";
+import { DiffViewer } from "../components/diff-viewer.js";
 import {
   SegmentedControl,
   SearchInput,
@@ -85,6 +86,7 @@ import {
   Paper, CircularProgress, Skeleton, Alert, Switch, FormControlLabel,
   Menu as MuiMenu, Fab, Table, TableBody, TableCell, TableContainer,
   TableHead, TableRow, TableSortLabel, ToggleButton, ToggleButtonGroup, Badge,
+  Autocomplete,
 } from "@mui/material";
 
 /* ─── View mode toggle ─── */
@@ -1245,9 +1247,12 @@ function buildTaskRelatedLinks(task) {
     "";
   const prNumber =
     task?.prNumber ||
+    task?.pr ||
     task?.pr_number ||
     task?.meta?.prNumber ||
+    task?.meta?.pr ||
     task?.meta?.pr_number ||
+    task?.meta?.pr?.number ||
     "";
   const prUrl =
     task?.prUrl ||
@@ -1258,13 +1263,72 @@ function buildTaskRelatedLinks(task) {
     "";
   const baseBranch = getTaskBaseBranch(task);
 
-  if (branch) links.push({ kind: "Branch", value: branch, url: "" });
+  if (branch) links.push({ kind: "Branch", value: branch, url: "", emphasis: true });
   if (baseBranch) links.push({ kind: "Base", value: baseBranch, url: "" });
-  if (prNumber) links.push({ kind: "PR", value: `#${prNumber}`, url: prUrl || "" });
+  if (prNumber) links.push({ kind: "PR", value: `#${prNumber}`, url: prUrl || "", emphasis: true });
   if (prUrl) links.push({ kind: "PR URL", value: prUrl, url: prUrl });
   return links;
 }
 
+function renderTaskRelatedLinks(relatedLinks, { onReviewDiff = null } = {}) {
+  if (!Array.isArray(relatedLinks) || !relatedLinks.length) {
+    if (!onReviewDiff) return "No branch or PR links recorded.";
+    return html`
+      <div style=${{ display: "flex", flexWrap: "wrap", gap: "8px", alignItems: "center" }}>
+        <button
+          type="button"
+          class="task-related-link-chip"
+          onClick=${onReviewDiff}
+        >
+          ${resolveIcon("edit") || "✎"} Review Diff
+        </button>
+      </div>
+    `;
+  }
+
+  return html`
+    <div style=${{ display: "flex", flexWrap: "wrap", gap: "8px", alignItems: "center" }}>
+      ${relatedLinks.map((item, index) => html`
+        ${item.url
+          ? html`
+              <a
+                key=${`task-link-${index}`}
+                class="task-related-link-chip"
+                data-emphasis=${item.emphasis ? "true" : "false"}
+                href=${item.url}
+                target="_blank"
+                rel="noopener noreferrer"
+              >
+                <span class="task-related-link-kind">${item.kind}</span>
+                <span class="task-related-link-value">${item.value}</span>
+              </a>
+            `
+          : html`
+              <span
+                key=${`task-link-${index}`}
+                class="task-related-link-chip"
+                data-emphasis=${item.emphasis ? "true" : "false"}
+              >
+                <span class="task-related-link-kind">${item.kind}</span>
+                <span class="task-related-link-value">${item.value}</span>
+              </span>
+            `}
+      `)}
+      ${onReviewDiff && html`
+        <button
+          type="button"
+          class="task-related-link-chip"
+          data-emphasis="true"
+          onClick=${onReviewDiff}
+        >
+          <span class="task-related-link-kind">Review</span>
+          <span class="task-related-link-value">Open Diff</span>
+        </button>
+      `}
+    </div>
+  `;
+}
+
 function buildTaskAgentList(task) {
   const values = [];
   const pushValue = (value) => {
@@ -1522,13 +1586,40 @@ export function StartTaskModal({
       <${Stack} spacing=${2}>
         ${(allowTaskIdInput || !task?.id) &&
         html`
-          <${TextField}
-            label="Task ID"
-            placeholder="e.g. task-123"
+          <${Autocomplete}
+            freeSolo
             size="small"
             fullWidth
-            value=${taskIdInput}
-            onChange=${(e) => setTaskIdInput(e.target.value)}
+            options=${(() => {
+              const STARTABLE = new Set(["draft", "backlog", "open", "new", "todo", "blocked", "error", "failed"]);
+
+              const getGroup = (s) => {
+                const lower = (s || "").toLowerCase();
+                if (lower === "draft") return "Draft";
+                if (["blocked", "error", "failed"].includes(lower)) return "Blocked";
+                return "Todo";
+              };
+              return (tasksData.value || [])
+                .filter(t => STARTABLE.has((t.status || "").toLowerCase()))
+                .map(t => ({ id: t.id, title: t.title || "(untitled)", status: t.status, group: getGroup(t.status) }))
+                .sort((a, b) => a.group.localeCompare(b.group) || (a.title || "").localeCompare(b.title || ""));
+            })()}
+            groupBy=${(opt) => opt.group || ""}
+            getOptionLabel=${(opt) => typeof opt === "string" ? opt : opt.title ? `${opt.title} (${opt.id})` : opt.id || ""}
+            isOptionEqualToValue=${(opt, val) => opt.id === (typeof val === "string" ? val : val?.id)}
+            inputValue=${taskIdInput}
+            onInputChange=${(_, val) => setTaskIdInput(val || "")}
+            onChange=${(_, val) => {
+              if (val && typeof val === "object" && val.id) {
+                setTaskIdInput(val.id);
+              } else if (typeof val === "string") {
+                setTaskIdInput(val);
+              }
+            }}
+            renderInput=${(params) => html`<${TextField} ...${params} label="Task ID" placeholder="Search or enter task ID" />`}
+            renderOption=${(props, opt) => html`<li ...${props} key=${opt.id}><${Box} sx=${{ display: "flex", flexDirection: "column" }}><${Typography} variant="body2">${opt.title}<//><${Typography} variant="caption" color="text.secondary">${opt.id}<//><//>
+            </li>`}
+            disablePortal
           />
         `}
         <${TextField}
@@ -2684,10 +2775,14 @@ export function TaskDetailModal({ task, onClose, onStart, presentation = "modal"
     task?.id,
     task?.branch,
     task?.branchName,
+    task?.pr,
     task?.prNumber,
     task?.prUrl,
     task?.meta,
   ]);
+  const handleOpenReviewDiff = useCallback(() => {
+    setActiveTab("diff");
+  }, []);
   const taskAgents = useMemo(() => buildTaskAgentList(task), [
     task?.id,
     task?.assignee,
@@ -3454,6 +3549,9 @@ export function TaskDetailModal({ task, onClose, onStart, presentation = "modal"
           ${resolveIcon("clock") || "⏱"} History
           ${historyEntries.length > 0 && html`<span class="task-tab-count">${historyEntries.length}</span>`}
         </button>
+        <button class="task-tab-btn" data-active=${activeTab === "diff"} onClick=${() => setActiveTab("diff")}>
+          ${resolveIcon("edit") || "✎"} Diff
+        </button>
       </div>
 
       ${/* ── Content Body ───────────────────────────────────────────── */ ""}
@@ -3812,7 +3910,7 @@ export function TaskDetailModal({ task, onClose, onStart, presentation = "modal"
               </div>
               <div class="task-comment-item">
                 <div class="task-comment-meta">Branch / PR</div>
-                <div class="task-comment-body">${relatedLinks.length ? relatedLinks.map((item) => `${item.kind}: ${item.value}`).join(" · ") : "No branch or PR links recorded."}</div>
+                <div class="task-comment-body">${renderTaskRelatedLinks(relatedLinks, { onReviewDiff: handleOpenReviewDiff })}</div>
               </div>
             </div>
           </div>
@@ -4580,6 +4678,18 @@ export function TaskDetailModal({ task, onClose, onStart, presentation = "modal"
       </div>`}
 
       ${/* ── HISTORY TAB ─────────────────────────────────────────────── */ ""}
+      ${activeTab === "diff" && html`
+        <div class="task-comments-block modal-form-span jira-panel">
+          <div class="task-attachments-title">Review Diff</div>
+          <div style=${{ display: "flex", flexDirection: "column", gap: "12px" }}>
+            <div class="task-comment-meta">
+              Compare the task branch or linked session against its recorded base so completed PRs stay reviewable from the task itself.
+            </div>
+            <${DiffViewer} taskId=${task?.id || ""} title=${task?.title || "Task Diff"} />
+          </div>
+        </div>
+      `}
+
       ${activeTab === "history" && html`<div style="display:contents;">
 
       ${historyEntries.length > 0 ? html`
@@ -4607,9 +4717,7 @@ export function TaskDetailModal({ task, onClose, onStart, presentation = "modal"
               <div class="task-comment-item" key=${`link-${index}`}>
                 <div class="task-comment-meta">${item.kind}</div>
                 <div class="task-comment-body">
-                  ${item.url
-                    ? html`<a href=${item.url} target="_blank" rel="noopener">${item.value}</a>`
-                    : item.value}
+                  ${renderTaskRelatedLinks([item])}
                 </div>
               </div>
             `)}

package/voice/voice-auth-manager.mjs

@@ -15,6 +15,14 @@ function normalizeProvider(provider) {
   return String(provider || "").trim().toLowerCase();
 }
 
+function normalizeEnvValue(value) {
+  const normalized = String(value ?? "").trim();
+  if (!normalized) return "";
+  const lowered = normalized.toLowerCase();
+  if (lowered === "undefined" || lowered === "null") return "";
+  return normalized;
+}
+
 function escapeHtml(value) {
   return String(value ?? "")
     .replace(/&/g, "&")
@@ -102,7 +110,7 @@ export function resolveVoiceOAuthToken(provider, forceReload = false) {
   if (!normalizedProvider) return null;
 
   const envToken = getProviderEnvCandidates(normalizedProvider)
-    .map((token) => String(token || "").trim())
+    .map((token) => normalizeEnvValue(token))
     .find(Boolean);
   if (envToken) {
     return {
@@ -212,11 +220,8 @@ function normalizeScopeList(scopes) {
 }
 
 function envOrDefault(name, fallback = "") {
-  const raw = process.env[name];
-  const value = String(raw ?? "").trim();
+  const value = normalizeEnvValue(process.env[name]);
   if (!value) return fallback;
-  const normalized = value.toLowerCase();
-  if (normalized === "undefined" || normalized === "null") return fallback;
   return value;
 }
 

package/workflow/workflow-engine.mjs

@@ -43,6 +43,7 @@ import {
 } from "../infra/test-runtime.mjs";
 import { getTemplate } from "./workflow-templates.mjs";
 import { WorkflowExecutionLedger } from "./execution-ledger.mjs";
+import { buildWorkflowStatusPayload } from "../infra/tui-bridge.mjs";
 
 // Lazy-loaded workspace manager for workspace-aware scheduling
 let _workspaceManagerMod = null;
@@ -65,6 +66,7 @@ function ensureWorkspaceManagerSync() {
 const TAG = "[workflow-engine]";
 const WORKFLOW_DIR_NAME = "workflows";
 const WORKFLOW_RUNS_DIR = "workflow-runs";
+const WORKFLOW_TRAJECTORIES_DIR = "trajectories";
 function readBoundedEnvInt(name, fallback, { min = 0, max = Number.MAX_SAFE_INTEGER } = {}) {
   const parsed = Number(process.env[name]);
   if (!Number.isFinite(parsed)) return fallback;
@@ -723,6 +725,15 @@ export class WorkflowContext {
       nodeInputs: { ...this._nodeInputs },
       dagState: this.data?._dagState || null,
       issueAdvisor: this.data?._issueAdvisor || null,
+      replayTrajectory: this.data?._replayTrajectory || null,
+      stepSummaries: Array.isArray(this.data?._replayTrajectory?.steps)
+        ? this.data._replayTrajectory.steps.map((s) => ({
+            nodeId: s.nodeId,
+            label: s.label,
+            status: s.status,
+            summary: s.summary,
+          }))
+        : [],
     };
   }
 }
@@ -783,6 +794,12 @@ export class WorkflowEngine extends EventEmitter {
     // Lazy-load workspace manager for schedule evaluation
     void ensureWorkspaceManager().catch(() => {});
   }
+  _emitWorkflowStatus(payload = {}) {
+    const event = buildWorkflowStatusPayload(payload);
+    if (!event.runId || !event.workflowId || !event.eventType) return;
+    this.emit("workflow:status", event);
+  }
+
 
   _initializeDagState(def, ctx, extra = {}) {
     const dependencyMap = new Map();
@@ -913,6 +930,57 @@ export class WorkflowEngine extends EventEmitter {
     return issueAdvisor;
   }
 
+  _buildStepSummary(node, { status = null, result = undefined, error = null } = {}) {
+    const nodeId = String(node?.id || "").trim() || null;
+    const label = String(node?.label || nodeId || "step").trim();
+    const normalizedStatus = String(status || "unknown").trim().toLowerCase() || "unknown";
+    let detail = null;
+    if (error) {
+      detail = String(error).trim();
+    } else if (result !== undefined) {
+      detail = this._summarizeTaskTraceNodeResult(result);
+    }
+    if (!detail) {
+      detail = normalizedStatus === "completed"
+        ? "Step completed successfully."
+        : (normalizedStatus === "failed" ? "Step failed." : `Step ${normalizedStatus}.`);
+    }
+    return {
+      nodeId,
+      label,
+      status: normalizedStatus,
+      summary: `${label}: ${detail}`,
+    };
+  }
+
+  _appendReplayTrajectoryStep(ctx, node, { status = null, result = undefined, error = null, attempt = undefined } = {}) {
+    if (!ctx || !node?.id) return;
+    const timing = ctx.getNodeTiming(node.id) || {};
+    const outputSummary = result !== undefined ? this._summarizeTaskTraceNodeResult(result) : null;
+    const replay =
+      ctx.data?._replayTrajectory && typeof ctx.data._replayTrajectory === "object"
+        ? ctx.data._replayTrajectory
+        : { runId: ctx.id, restoredFrom: ctx.data?._restoredFrom || null, steps: [] };
+    const step = {
+      nodeId: node.id,
+      type: node.type || null,
+      label: node.label || null,
+      status: status || null,
+      attempt: Number.isFinite(Number(attempt)) ? Number(attempt) : ctx.getRetryCount(node.id),
+      startedAt: Number.isFinite(Number(timing.startedAt)) ? Number(timing.startedAt) : null,
+      endedAt: Number.isFinite(Number(timing.endedAt)) ? Number(timing.endedAt) : null,
+      input: ctx.getNodeInput(node.id) || null,
+      outputSummary,
+      error: error ? String(error) : null,
+      summary: this._buildStepSummary(node, { status, result, error }).summary,
+    };
+    replay.runId = ctx.id;
+    replay.restoredFrom = ctx.data?._restoredFrom || replay.restoredFrom || null;
+    replay.steps = Array.isArray(replay.steps) ? replay.steps.filter((entry) => entry?.nodeId !== node.id) : [];
+    replay.steps.push(step);
+    ctx.data._replayTrajectory = replay;
+  }
+
   _recordDagNodeOutcome(ctx, node, {
     status,
     result = undefined,
@@ -942,6 +1010,7 @@ export class WorkflowEngine extends EventEmitter {
           : undefined,
     });
     ctx.annotateDagNode(node.id, nodePatch);
+    this._appendReplayTrajectoryStep(ctx, node, { status, result, error, attempt });
     const workflowStatus = error
       ? WorkflowStatus.FAILED
       : (ctx.data?._workflowTerminalStatus || WorkflowStatus.RUNNING);
@@ -1386,6 +1455,7 @@ export class WorkflowEngine extends EventEmitter {
 
   // ── Execution ─────────────────────────────────────────────────────────
 
+
   /**
    * Execute a workflow with given input data.
    * @param {string} workflowId
@@ -1520,6 +1590,16 @@ export class WorkflowEngine extends EventEmitter {
     this._persistActiveRunState(runId, workflowId, def.name, ctx);
 
     this.emit("run:start", { runId, workflowId, name: def.name });
+    this._emitWorkflowStatus({
+      runId,
+      workflowId,
+      workflowName: def.name,
+      eventType: "run:start",
+      status: WorkflowStatus.RUNNING,
+      meta: {
+        triggerSource: ctx.data?._triggerSource || null,
+      },
+    });
     this._recordLedgerEvent({
       eventType: "run.start",
       runId,
@@ -1560,7 +1640,30 @@ export class WorkflowEngine extends EventEmitter {
       const status = this._resolveWorkflowStatus(ctx);
       this._activeRuns.get(runId).status = status;
       this._refreshDagState(ctx, status);
+      const terminalError = Array.isArray(ctx.errors) && ctx.errors.length
+        ? String(ctx.errors[ctx.errors.length - 1]?.error || "").trim()
+        : "";
+      if (status === WorkflowStatus.FAILED && terminalError) {
+        this.emit("run:error", { runId, workflowId, error: terminalError });
+        this._emitWorkflowStatus({
+          runId,
+          workflowId,
+          workflowName: def.name,
+          eventType: "run:error",
+          status: WorkflowStatus.FAILED,
+          error: terminalError,
+          durationMs: Date.now() - ctx.startedAt,
+        });
+      }
       this.emit("run:end", { runId, workflowId, status, duration: Date.now() - ctx.startedAt });
+      this._emitWorkflowStatus({
+        runId,
+        workflowId,
+        workflowName: def.name,
+        eventType: "run:end",
+        status,
+        durationMs: Date.now() - ctx.startedAt,
+      });
       this._recordLedgerEvent({
         eventType: "run.end",
         runId,
@@ -1590,6 +1693,15 @@ export class WorkflowEngine extends EventEmitter {
       this._activeRuns.get(runId).status = WorkflowStatus.FAILED;
       this._refreshDagState(ctx, WorkflowStatus.FAILED);
       this.emit("run:error", { runId, workflowId, error: err.message });
+      this._emitWorkflowStatus({
+        runId,
+        workflowId,
+        workflowName: def.name,
+        eventType: "run:error",
+        status: WorkflowStatus.FAILED,
+        error: err.message,
+        durationMs: Date.now() - ctx.startedAt,
+      });
       this._recordLedgerEvent({
         eventType: "run.error",
         runId,
@@ -1754,6 +1866,14 @@ export class WorkflowEngine extends EventEmitter {
     });
     this._persistActiveRunState(retryRunId, workflowId, def.name, ctx);
     this.emit("run:start", { runId: retryRunId, workflowId, name: def.name, retryOf: runId, mode });
+    this._emitWorkflowStatus({
+      runId: retryRunId,
+      workflowId,
+      workflowName: def.name,
+      eventType: "run:start",
+      status: WorkflowStatus.RUNNING,
+      meta: { retryOf: runId, mode },
+    });
     this._recordLedgerEvent({
       eventType: "run.start",
       runId: retryRunId,
@@ -1799,6 +1919,15 @@ export class WorkflowEngine extends EventEmitter {
         retryOf: runId,
         mode,
       });
+      this._emitWorkflowStatus({
+        runId: retryRunId,
+        workflowId,
+        workflowName: def.name,
+        eventType: "run:end",
+        status,
+        durationMs: Date.now() - ctx.startedAt,
+        meta: { retryOf: runId, mode },
+      });
       this._recordLedgerEvent({
         eventType: "run.end",
         runId: retryRunId,
@@ -1829,6 +1958,16 @@ export class WorkflowEngine extends EventEmitter {
       this._activeRuns.get(retryRunId).status = WorkflowStatus.FAILED;
       this._refreshDagState(ctx, WorkflowStatus.FAILED);
       this.emit("run:error", { runId: retryRunId, workflowId, error: err.message, retryOf: runId });
+      this._emitWorkflowStatus({
+        runId: retryRunId,
+        workflowId,
+        workflowName: def.name,
+        eventType: "run:error",
+        status: WorkflowStatus.FAILED,
+        error: err.message,
+        durationMs: Date.now() - ctx.startedAt,
+        meta: { retryOf: runId, mode },
+      });
       this._recordLedgerEvent({
         eventType: "run.error",
         runId: retryRunId,
@@ -2636,9 +2775,16 @@ export class WorkflowEngine extends EventEmitter {
     const detail = run.detail || {};
     const workflowId = run.workflowId || detail.data?._workflowId;
     const snapshotsDir = resolve(this.runsDir, "snapshots");
+    const trajectoriesDir = resolve(this.runsDir, WORKFLOW_TRAJECTORIES_DIR);
     mkdirSync(snapshotsDir, { recursive: true });
+    mkdirSync(trajectoriesDir, { recursive: true });
     const snapshotId = runId;
     const snapshotPath = resolve(snapshotsDir, `${snapshotId}.json`);
+    const trajectoryPath = resolve(trajectoriesDir, `${snapshotId}.json`);
+    const replayTrajectory =
+      detail.replayTrajectory && typeof detail.replayTrajectory === "object"
+        ? detail.replayTrajectory
+        : { runId, restoredFrom: detail?.data?._restoredFrom || null, steps: [] };
     const snapshot = {
       snapshotId,
       runId,
@@ -2651,9 +2797,12 @@ export class WorkflowEngine extends EventEmitter {
       retryAttempts: detail.retryAttempts || {},
       variables: detail.data || {},
       errors: detail.errors || [],
+      replayTrajectory,
+      stepSummaries: detail.stepSummaries || [],
     };
     writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2), "utf8");
-    return { snapshotId, path: snapshotPath };
+    writeFileSync(trajectoryPath, JSON.stringify(replayTrajectory, null, 2), "utf8");
+    return { snapshotId, path: snapshotPath, trajectoryPath };
   }
 
   /**
@@ -2693,6 +2842,13 @@ export class WorkflowEngine extends EventEmitter {
     ctx.data._workflowId = workflowId;
     ctx.data._workflowName = def.name;
     ctx.data._restoredFrom = snapshotId;
+    ctx.data._replayTrajectory = {
+      runId: ctx.id,
+      restoredFrom: snapshotId,
+      steps: Array.isArray(snapshot.replayTrajectory?.steps)
+        ? snapshot.replayTrajectory.steps.map((step) => ({ ...step }))
+        : [],
+    };
     ctx.variables = { ...def.variables, ...(opts.variables || {}) };
 
     // Pre-seed completed nodes from snapshot
@@ -2716,6 +2872,14 @@ export class WorkflowEngine extends EventEmitter {
       status: WorkflowStatus.RUNNING,
     });
     this.emit("run:start", { runId: retryRunId, workflowId, name: def.name, restoredFrom: snapshotId });
+    this._emitWorkflowStatus({
+      runId: retryRunId,
+      workflowId,
+      workflowName: def.name,
+      eventType: "run:start",
+      status: WorkflowStatus.RUNNING,
+      meta: { restoredFrom: snapshotId },
+    });
 
     try {
       const adjacency = this._buildAdjacency(def);
@@ -2746,11 +2910,13 @@ export class WorkflowEngine extends EventEmitter {
       try {
         const data = JSON.parse(readFileSync(resolve(snapshotsDir, file), "utf8"));
         if (workflowId && data.workflowId !== workflowId) continue;
+        const trajectoryFile = resolve(snapshotsDir, "..", WORKFLOW_TRAJECTORIES_DIR, `${data.snapshotId}.json`);
         snapshots.push({
           snapshotId: data.snapshotId,
           runId: data.runId,
           workflowId: data.workflowId,
           createdAt: data.createdAt,
+          hasTrajectory: existsSync(trajectoryFile),
         });
       } catch {
         // skip corrupt snapshot files
@@ -3053,6 +3219,17 @@ export class WorkflowEngine extends EventEmitter {
                 status: NodeStatus.COMPLETED,
                 output: result,
               });
+              this._emitWorkflowStatus({
+                runId: ctx.id,
+                workflowId,
+                workflowName,
+                eventType: "node:complete",
+                status: NodeStatus.COMPLETED,
+                nodeId,
+                nodeType: node?.type || null,
+                nodeLabel: node?.label || null,
+                meta: { attempt: ctx.getRetryCount(nodeId) },
+              });
               this._recordLedgerEvent({
                 eventType: "node.completed",
                 runId: ctx.id,
@@ -4368,3 +4545,4 @@ export function listWorkflows(opts) { return getWorkflowEngine(opts).list(); }
 export function getWorkflow(id, opts) { return getWorkflowEngine(opts).get(id); }
 export async function executeWorkflow(id, data, opts) { return getWorkflowEngine(opts).execute(id, data, opts); }
 export async function retryWorkflowRun(runId, retryOpts, engineOpts) { return getWorkflowEngine(engineOpts).retryRun(runId, retryOpts); }
+