bosun 0.42.2 → 0.42.4

package/infra/tui-bridge.mjs

@@ -18,6 +18,9 @@ const RATE_LIMIT_BUCKET_SCHEMA = {
     primary: { type: ["number", "null"] },
     secondary: { type: ["number", "null"] },
     credits: { type: ["number", "null"] },
+    primaryLimit: { type: ["number", "null"] },
+    secondaryLimit: { type: ["number", "null"] },
+    creditsLimit: { type: ["number", "null"] },
     unit: { type: "string", minLength: 1 },
   },
 };
@@ -74,6 +77,7 @@ export const TUI_EVENT_SCHEMAS = Object.freeze({
       "tokensIn",
       "tokensOut",
       "tokensTotal",
+      "totalTokens",
       "throughputTps",
       "uptimeMs",
       "rateLimits",
@@ -85,6 +89,7 @@ export const TUI_EVENT_SCHEMAS = Object.freeze({
       tokensIn: { type: "number", minimum: 0 },
       tokensOut: { type: "number", minimum: 0 },
       tokensTotal: { type: "number", minimum: 0 },
+      totalTokens: { type: "number", minimum: 0 },
       throughputTps: { type: "number", minimum: 0 },
       uptimeMs: { type: "number", minimum: 0 },
       rateLimits: {
@@ -208,6 +213,9 @@ function normalizeRateLimits(rateLimits = {}) {
       primary: Number.isFinite(Number(bucket.primary)) ? Number(bucket.primary) : null,
       secondary: Number.isFinite(Number(bucket.secondary)) ? Number(bucket.secondary) : null,
       credits: bucket.credits == null ? null : (Number.isFinite(Number(bucket.credits)) ? Number(bucket.credits) : null),
+      primaryLimit: bucket.primaryLimit == null ? null : (Number.isFinite(Number(bucket.primaryLimit)) ? Number(bucket.primaryLimit) : null),
+      secondaryLimit: bucket.secondaryLimit == null ? null : (Number.isFinite(Number(bucket.secondaryLimit)) ? Number(bucket.secondaryLimit) : null),
+      creditsLimit: bucket.creditsLimit == null ? null : (Number.isFinite(Number(bucket.creditsLimit)) ? Number(bucket.creditsLimit) : null),
       unit: String(bucket.unit || "count").trim() || "count",
     };
   }
@@ -237,7 +245,10 @@ export function buildMonitorStatsPayload({ agentPool, runtimeStats = {}, uptimeM
     agentPoolStats.tokensOut,
     runtimeStats.totalOutputTokens ?? runtimeTokenTotals.tokensOut,
   );
-  const tokensTotal = nonNegativeNumber(agentPoolStats.tokensTotal, tokensIn + tokensOut);
+  const tokensTotal = nonNegativeNumber(
+    agentPoolStats.tokensTotal ?? agentPoolStats.totalTokens,
+    tokensIn + tokensOut,
+  );
   const resolvedUptimeMs = nonNegativeNumber(
     uptimeMs,
     runtimeStats.startedAt ? Date.now() - Number(runtimeStats.startedAt) : 0,
@@ -252,6 +263,7 @@ export function buildMonitorStatsPayload({ agentPool, runtimeStats = {}, uptimeM
     tokensIn,
     tokensOut,
     tokensTotal,
+    totalTokens: tokensTotal,
     throughputTps,
     uptimeMs: resolvedUptimeMs,
     rateLimits: normalizeRateLimits(agentPoolStats.rateLimits),

package/kanban/kanban-adapter.mjs

@@ -62,6 +62,7 @@ import {
   setTaskStatus as setInternalTaskStatus,
   removeTask as removeInternalTask,
   updateTask as patchInternalTask,
+  waitForStoreWrites,
 } from "../task/task-store.mjs";
 import {
   listTaskAttachments,
@@ -673,6 +674,101 @@ function extractMarkdownLinks(text) {
   return results;
 }
 
+function normalizePrLinkageEntry(entry = {}, fallback = {}) {
+  const safeEntry = entry && typeof entry === "object" ? entry : {};
+  const safeFallback = fallback && typeof fallback === "object" ? fallback : {};
+  const branchName = typeof (safeEntry.branchName ?? safeFallback.branchName) === "string"
+    ? String(safeEntry.branchName ?? safeFallback.branchName).trim()
+    : "";
+  const prUrl = typeof (safeEntry.prUrl ?? safeFallback.prUrl) === "string"
+    ? String(safeEntry.prUrl ?? safeFallback.prUrl).trim()
+    : "";
+  const parsedPrNumber = Number.parseInt(String(safeEntry.prNumber ?? safeFallback.prNumber ?? ""), 10);
+  const prNumber = Number.isFinite(parsedPrNumber) && parsedPrNumber > 0 ? parsedPrNumber : null;
+  if (!branchName && !prUrl && !prNumber) return null;
+  return {
+    branchName: branchName || null,
+    prUrl: prUrl || null,
+    prNumber,
+    source: typeof (safeEntry.source ?? safeFallback.source) === "string" && String(safeEntry.source ?? safeFallback.source).trim()
+      ? String(safeEntry.source ?? safeFallback.source).trim()
+      : null,
+    freshness: typeof (safeEntry.freshness ?? safeFallback.freshness) === "string" && String(safeEntry.freshness ?? safeFallback.freshness).trim()
+      ? String(safeEntry.freshness ?? safeFallback.freshness).trim()
+      : null,
+    linkedAt: typeof (safeEntry.linkedAt ?? safeFallback.linkedAt) === "string" && String(safeEntry.linkedAt ?? safeFallback.linkedAt).trim()
+      ? String(safeEntry.linkedAt ?? safeFallback.linkedAt).trim()
+      : null,
+    updatedAt: typeof (safeEntry.updatedAt ?? safeFallback.updatedAt) === "string" && String(safeEntry.updatedAt ?? safeFallback.updatedAt).trim()
+      ? String(safeEntry.updatedAt ?? safeFallback.updatedAt).trim()
+      : null,
+  };
+}
+
+function mergePrLinkageRecords(...sources) {
+  const merged = [];
+  const indexByKey = new Map();
+  const buildKey = (entry) => {
+    const branchName = String(entry?.branchName || "").trim().toLowerCase();
+    const prUrl = String(entry?.prUrl || "").trim().toLowerCase();
+    const prNumber = Number.isFinite(entry?.prNumber) ? entry.prNumber : "";
+    return [branchName, prNumber, prUrl].join("|");
+  };
+  for (const source of sources) {
+    const entries = Array.isArray(source) ? source : [];
+    for (const rawEntry of entries) {
+      const entry = normalizePrLinkageEntry(rawEntry);
+      if (!entry) continue;
+      const key = buildKey(entry);
+      if (!key) continue;
+      if (indexByKey.has(key)) {
+        const idx = indexByKey.get(key);
+        merged[idx] = normalizePrLinkageEntry({ ...merged[idx], ...entry }, merged[idx]);
+        continue;
+      }
+      indexByKey.set(key, merged.length);
+      merged.push(entry);
+    }
+  }
+  return merged;
+}
+
+function buildPrLinkagePatch(options = {}, currentTask = null) {
+  const branchName = typeof options?.branchName === "string" ? options.branchName.trim() : "";
+  const prUrl = typeof options?.prUrl === "string" ? options.prUrl.trim() : "";
+  const prNumber = options?.prNumber == null || options?.prNumber === ""
+    ? null
+    : Number.parseInt(String(options.prNumber), 10);
+  const source = typeof options?.source === "string" && options.source.trim() ? options.source.trim() : null;
+  const freshness = typeof options?.freshness === "string" && options.freshness.trim() ? options.freshness.trim() : null;
+  const currentMeta = currentTask?.meta && typeof currentTask.meta === "object" ? currentTask.meta : {};
+  const currentLinkage = mergePrLinkageRecords(currentTask?.prLinkage, currentMeta?.prLinkage);
+  const nextEntry = normalizePrLinkageEntry({
+    branchName,
+    prUrl,
+    prNumber: Number.isFinite(prNumber) && prNumber > 0 ? prNumber : null,
+    source,
+    freshness,
+    updatedAt: new Date().toISOString(),
+    linkedAt: currentLinkage[0]?.linkedAt || new Date().toISOString(),
+  }, currentTask || {});
+  if (!nextEntry) return {};
+  const prLinkage = mergePrLinkageRecords(currentLinkage, [nextEntry]);
+  return {
+    ...(nextEntry.branchName ? { branchName: nextEntry.branchName } : {}),
+    ...(nextEntry.prUrl ? { prUrl: nextEntry.prUrl } : {}),
+    ...(Number.isFinite(nextEntry.prNumber) && nextEntry.prNumber > 0 ? { prNumber: nextEntry.prNumber } : {}),
+    prLinkage,
+    meta: {
+      ...currentMeta,
+      prLinkage,
+      prLinkageSource: nextEntry.source || currentMeta.prLinkageSource || null,
+      prLinkageFreshness: nextEntry.freshness || currentMeta.prLinkageFreshness || null,
+      prLinkageUpdatedAt: nextEntry.updatedAt || currentMeta.prLinkageUpdatedAt || null,
+    },
+  };
+}
+
 function extractAttachmentsFromText(text, meta = {}) {
   const links = extractMarkdownLinks(text);
   const attachments = [];
@@ -792,6 +888,8 @@ class InternalAdapter {
       existingAttachments,
       localAttachments,
     );
+    const prLinkage = mergePrLinkageRecords(task.prLinkage, task.meta?.prLinkage, [normalizePrLinkageEntry(task, task)]);
+    const primaryPrLinkage = prLinkage[0] || null;
     return {
       id: String(task.id || ""),
       title: recoveredTitle || "",
@@ -816,9 +914,10 @@ class InternalAdapter {
             ? task.meta.repositories
             : [],
       baseBranch,
-      branchName: task.branchName || null,
-      prNumber: task.prNumber || null,
-      prUrl: task.prUrl || null,
+      branchName: task.branchName || primaryPrLinkage?.branchName || null,
+      prLinkage,
+      prNumber: task.prNumber || primaryPrLinkage?.prNumber || null,
+      prUrl: task.prUrl || primaryPrLinkage?.prUrl || null,
       taskUrl: task.taskUrl || null,
       createdAt: task.createdAt || null,
       updatedAt: task.updatedAt || null,
@@ -836,6 +935,10 @@ class InternalAdapter {
         statusHistory: Array.isArray(task.statusHistory) ? task.statusHistory : (Array.isArray(task.meta?.statusHistory) ? task.meta.statusHistory : []),
         comments: normalizedComments,
         attachments: mergedAttachments,
+        prLinkage,
+        prLinkageSource: primaryPrLinkage?.source || task.meta?.prLinkageSource || null,
+        prLinkageFreshness: primaryPrLinkage?.freshness || task.meta?.prLinkageFreshness || null,
+        prLinkageUpdatedAt: primaryPrLinkage?.updatedAt || task.meta?.prLinkageUpdatedAt || null,
       },
     };
   }
@@ -895,7 +998,8 @@ class InternalAdapter {
     if (!updated) {
       throw new Error(`[kanban] internal task not found: ${normalizedId}`);
     }
-    const linkagePatch = {};
+    const current = getInternalTask(normalizedId);
+    const linkagePatch = buildPrLinkagePatch(options, current);
     const branchName =
       typeof options?.branchName === "string" ? options.branchName.trim() : "";
     const prUrl = typeof options?.prUrl === "string" ? options.prUrl.trim() : "";
@@ -908,8 +1012,10 @@ class InternalAdapter {
     if (Number.isFinite(prNumber) && prNumber > 0) linkagePatch.prNumber = prNumber;
     if (Object.keys(linkagePatch).length > 0) {
       const patched = patchInternalTask(normalizedId, linkagePatch);
+      await waitForStoreWrites();
       if (patched) return this._normalizeTask(patched);
     }
+    await waitForStoreWrites();
     return this._normalizeTask(updated);
   }
 
@@ -1018,10 +1124,26 @@ class InternalAdapter {
         baseBranch,
       };
     }
+    const directLinkage = mergePrLinkageRecords(current?.prLinkage, current?.meta?.prLinkage, patch.prLinkage, patch.meta?.prLinkage, [normalizePrLinkageEntry(patch, patch)]);
+    if (directLinkage.length > 0) {
+      const primaryPrLinkage = directLinkage[0] || null;
+      updates.prLinkage = directLinkage;
+      updates.branchName = updates.branchName ?? primaryPrLinkage?.branchName ?? null;
+      updates.prUrl = updates.prUrl ?? primaryPrLinkage?.prUrl ?? null;
+      updates.prNumber = updates.prNumber ?? primaryPrLinkage?.prNumber ?? null;
+      updates.meta = {
+        ...(updates.meta || current?.meta || {}),
+        prLinkage: directLinkage,
+        prLinkageSource: primaryPrLinkage?.source || updates.meta?.prLinkageSource || current?.meta?.prLinkageSource || null,
+        prLinkageFreshness: primaryPrLinkage?.freshness || updates.meta?.prLinkageFreshness || current?.meta?.prLinkageFreshness || null,
+        prLinkageUpdatedAt: primaryPrLinkage?.updatedAt || updates.meta?.prLinkageUpdatedAt || current?.meta?.prLinkageUpdatedAt || null,
+      };
+    }
     const updated = patchInternalTask(normalizedId, updates);
     if (!updated) {
       throw new Error(`[kanban] internal task not found: ${normalizedId}`);
     }
+    await waitForStoreWrites();
     return this._normalizeTask(updated);
   }
 
@@ -1108,6 +1230,7 @@ class InternalAdapter {
     if (!created) {
       throw new Error("[kanban] internal task creation failed");
     }
+    await waitForStoreWrites();
     return this._normalizeTask(created);
   }
 
@@ -6198,3 +6321,4 @@ export async function unmarkTaskIgnored(taskId) {
   );
   return false;
 }
+

package/lib/repo-map.mjs

@@ -3,6 +3,7 @@ import { extname, join, resolve } from "node:path";
 
 const DEFAULT_FILE_LIMIT = 12;
 const DEFAULT_MAX_SYMBOLS = 4;
+const DEFAULT_TOPOLOGY_SUMMARY_LIMIT = 96;
 const QUERY_STOP_WORDS = new Set([
   "about", "after", "again", "agent", "along", "also", "architect", "before", "being", "bosun",
   "build", "changes", "check", "code", "create", "debug", "editor", "ensure", "feature", "files",
@@ -35,6 +36,24 @@ function uniqueStrings(values) {
   return [...new Set((Array.isArray(values) ? values : []).map((value) => String(value || "").trim()).filter(Boolean))];
 }
 
+function truncateText(value, limit = DEFAULT_TOPOLOGY_SUMMARY_LIMIT) {
+  const text = String(value || "").trim();
+  const max = toPositiveInt(limit, DEFAULT_TOPOLOGY_SUMMARY_LIMIT);
+  if (!text || text.length <= max) return text;
+  if (max <= 3) return text.slice(0, max);
+  const ellipsis = "...";
+  const sliceLength = Math.max(1, max - ellipsis.length);
+  const nextWordBreak = text.indexOf(" ", sliceLength);
+  if (nextWordBreak > sliceLength && nextWordBreak - sliceLength <= 12) {
+    return `${text.slice(0, nextWordBreak).trimEnd()}${ellipsis}`;
+  }
+  const truncated = text.slice(0, sliceLength);
+  const lastWordBreak = truncated.lastIndexOf(" ");
+  const prefersWordBoundary = lastWordBreak >= Math.floor(sliceLength * 0.6);
+  const display = prefersWordBoundary ? truncated.slice(0, lastWordBreak) : truncated;
+  return `${display.trimEnd()}${ellipsis}`;
+}
+
 function isTokenWordChar(char) {
   if (!char) return false;
   const code = char.charCodeAt(0);
@@ -132,6 +151,92 @@ export function formatRepoMap(repoMap, opts = {}) {
   return lines.join("\n");
 }
 
+function inferRepoOwner(pathValue) {
+  const normalizedPath = String(pathValue || "").trim().replace(/\\/g, "/");
+  if (!normalizedPath) return "root";
+  const segments = normalizedPath.split("/");
+  if (segments.length === 1) return "root";
+  const [owner] = segments;
+  return owner || "root";
+}
+
+function normalizeAdjacencyStem(pathValue) {
+  return String(pathValue || "")
+    .trim()
+    .replace(/\\/g, "/")
+    .split("/")
+    .pop()?.toLowerCase()
+    .replace(/(\.node)?\.test\.[^.]+$/i, "")
+    .replace(/\.spec\.[^.]+$/i, "")
+    .replace(/\.runtime\.[^.]+$/i, "")
+    .replace(/\.[^.]+$/i, "")
+    || "";
+}
+
+function scoreRepoAdjacency(left, right) {
+  if (!left || !right || left.path === right.path) return -1;
+  const leftPath = String(left.path || "").replace(/\\/g, "/");
+  const rightPath = String(right.path || "").replace(/\\/g, "/");
+  const leftDir = leftPath.includes("/") ? leftPath.split("/").slice(0, -1).join("/") : "";
+  const rightDir = rightPath.includes("/") ? rightPath.split("/").slice(0, -1).join("/") : "";
+  const leftOwner = inferRepoOwner(leftPath);
+  const rightOwner = inferRepoOwner(rightPath);
+  const leftStem = normalizeAdjacencyStem(leftPath);
+  const rightStem = normalizeAdjacencyStem(rightPath);
+  let score = 0;
+  if (leftDir && leftDir === rightDir) score += 60;
+  if (leftOwner && leftOwner === rightOwner) score += 25;
+  if (leftStem && leftStem === rightStem) score += 40;
+  if ((leftOwner === "tests" || rightOwner === "tests") && leftStem && leftStem === rightStem) score += 30;
+  return score;
+}
+
+export function hasRepoMapContext(value = "") {
+  const text = String(value || "");
+  return text.includes("## Repo Topology") || text.includes("## Repo Map");
+}
+
+export function formatRepoTopology(repoMap, opts = {}) {
+  const normalized = normalizeRepoMap(repoMap, opts);
+  if (!normalized) return "";
+  const files = Array.isArray(normalized.files) ? normalized.files : [];
+  const lines = [String(opts.title || "## Repo Topology")];
+  const summaryLimit = toPositiveInt(opts.repoMapSummaryLimit || opts.summaryLimit, DEFAULT_TOPOLOGY_SUMMARY_LIMIT);
+  if (normalized.root) lines.push(`- Root: ${normalized.root}`);
+  if (files.length === 0) return lines.join("\n");
+
+  const areaCounts = new Map();
+  for (const file of files) {
+    const owner = inferRepoOwner(file.path);
+    areaCounts.set(owner, (areaCounts.get(owner) || 0) + 1);
+  }
+  const areas = [...areaCounts.entries()]
+    .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+    .map(([owner, count]) => `${owner} (${count})`);
+  if (areas.length) lines.push(`- Areas: ${areas.join(", ")}`);
+
+  const adjacencyLimit = toPositiveInt(opts.repoMapAdjacencyLimit || opts.adjacencyLimit, 2);
+  for (const file of files) {
+    const owner = inferRepoOwner(file.path);
+    const summary = truncateText(file.summary, summaryLimit);
+    const adjacent = files
+      .map((candidate) => ({ path: candidate.path, score: scoreRepoAdjacency(file, candidate) }))
+      .filter((candidate) => candidate.score > 0)
+      .sort((left, right) => right.score - left.score || left.path.localeCompare(right.path))
+      .slice(0, adjacencyLimit)
+      .map((candidate) => candidate.path);
+    const parts = [file.path, `owner: ${owner}`];
+    if (summary) parts.push(summary);
+    if (adjacent.length) parts.push(`adjacent: ${adjacent.join(", ")}`);
+    lines.push(`- ${parts.join(" — ")}`);
+  }
+  return lines.join("\n");
+}
+
+export function buildRepoTopologyContext(options = {}) {
+  return formatRepoTopology(buildRepoMap(options), options);
+}
+
 function resolveRootDir(options = {}) {
   const explicit = String(options.rootDir || options.repoRoot || options.cwd || "").trim();
   if (explicit) return explicit.replace(/\\/g, "/");
@@ -378,7 +483,9 @@ export function inferExecutionRole(options = {}, effectiveMode = "agent") {
 
 export function buildArchitectEditorFrame(options = {}, effectiveMode = "agent") {
   const executionRole = inferExecutionRole(options, effectiveMode);
-  const repoMapBlock = formatRepoMap(buildRepoMap(options), options);
+  const repoMapBlock = options.includeRepoMap === false
+    ? ""
+    : formatRepoTopology(buildRepoMap(options), options);
   const architectPlan = String(options.architectPlan || options.planSummary || "").trim();
   const lines = ["## Architect/Editor Execution"];
 
@@ -386,14 +493,14 @@ export function buildArchitectEditorFrame(options = {}, effectiveMode = "agent")
     lines.push(
       "You are the architect phase.",
       "Do not implement code changes in this phase.",
-      "Use the repo map to produce a compact structural plan that an editor can execute and validate.",
+      "Use the repo topology to produce a compact structural plan that an editor can execute and validate.",
       "Editor handoff: include ordered implementation steps, touched files, risks, and validation guidance.",
     );
   } else if (executionRole === "editor") {
     lines.push(
       "You are the editor phase.",
       "Implement the approved plan with focused edits and verification.",
-      "Prefer the supplied repo map over broad rediscovery unless validation reveals drift.",
+      "Prefer the supplied repo topology over broad rediscovery unless validation reveals drift.",
     );
     if (architectPlan) {
       lines.push("", "## Architect Plan", architectPlan);
@@ -409,3 +516,7 @@ export function buildArchitectEditorFrame(options = {}, effectiveMode = "agent")
   return lines.join("\n");
 }
 
+
+
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.42.2",
+  "version": "0.42.4",
   "description": "Bosun Autonomous Engineering — manages AI agent executors with failover, extremely powerful workflow builder, and a massive amount of included default workflow templates for autonomous engineering, 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",
@@ -383,7 +383,16 @@
     "preact": "10.25.4",
     "qrcode-terminal": "^0.12.0",
     "vibe-kanban": "latest",
-    "ws": "^8.19.0"
+    "ws": "^8.19.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.206.0",
+    "@opentelemetry/resources": "^2.1.0",
+    "@opentelemetry/sdk-metrics": "^2.1.0",
+    "@opentelemetry/sdk-trace-base": "^2.1.0",
+    "@opentelemetry/semantic-conventions": "^1.37.0",
+    "figures": "^6.1.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
   },
   "devDependencies": {
     "@emotion/react": "^11.14.0",
@@ -391,8 +400,6 @@
     "@mui/material": "^5.18.0",
     "@playwright/test": "^1.58.2",
     "playwright": "^1.58.2",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
     "vitest": "^4.0.18"
   },
   "engines": {

package/server/ui-server.mjs

@@ -11988,6 +11988,9 @@ async function listReplayableAgentRuns(options = {}) {
 async function readReplayableAgentRun(attemptId) {
   const normalizedAttemptId = String(attemptId || "").trim();
   if (!normalizedAttemptId) return null;
+  // Ensure attemptId cannot perform path traversal or escape the intended directory.
+  // Only allow simple identifiers composed of letters, digits, underscore, and dash.
+  if (!/^[a-zA-Z0-9_-]+$/.test(normalizedAttemptId)) return null;
   const filePath = resolve(resolveAgentWorkLogDir(), "agent-sessions", `${normalizedAttemptId}.jsonl`);
   if (!existsSync(filePath)) return null;
   const entries = await readJsonlTail(filePath, 20000, 25000000).catch(() => []);

package/task/task-archiver.mjs

@@ -31,6 +31,7 @@ import { existsSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { randomBytes } from "node:crypto";
+import { normalizeTaskStorageRecord } from "./task-store.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -173,7 +174,7 @@ export async function archiveTaskToFile(
     }
 
     const archiveEntry = {
-      task,
+      task: normalizeTaskStorageRecord(task),
       attempt: attemptData,
       archived_at: new Date().toISOString(),
       archiver_version: 3,
@@ -470,7 +471,7 @@ export async function migrateLegacyArchives(archiveDir = ARCHIVE_DIR) {
         for (const legacyFile of fileNames) {
           try {
             const raw = await readFile(resolve(archiveDir, legacyFile), "utf8");
-            const entry = JSON.parse(raw);
+            const entry = normalizeArchiveEntry(JSON.parse(raw));
             const taskId = entry?.task?.id;
 
             if (taskId && existingIds.has(taskId)) {
@@ -663,8 +664,9 @@ export async function loadArchivedTasks(options = {}) {
         // Daily grouped file: array of entries
         if (Array.isArray(data)) {
           for (const entry of data) {
-            if (matchesFilters(entry, since, until, statusFilter)) {
-              archivedTasks.push(entry);
+            const normalizedEntry = normalizeArchiveEntry(entry);
+            if (matchesFilters(normalizedEntry, since, until, statusFilter)) {
+              archivedTasks.push(normalizedEntry);
             }
           }
           continue;
@@ -672,8 +674,9 @@ export async function loadArchivedTasks(options = {}) {
 
         // Legacy single-task file: object with { task, archived_at, ... }
         if (data && typeof data === "object" && data.task) {
-          if (matchesFilters(data, since, until, statusFilter)) {
-            archivedTasks.push(data);
+          const normalizedEntry = normalizeArchiveEntry(data);
+          if (matchesFilters(normalizedEntry, since, until, statusFilter)) {
+            archivedTasks.push(normalizedEntry);
           }
         }
       } catch {
@@ -701,6 +704,15 @@ function matchesFilters(entry, since, until, statusFilter) {
   return true;
 }
 
+function normalizeArchiveEntry(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const normalized = { ...entry };
+  if (normalized.task && typeof normalized.task === "object") {
+    normalized.task = normalizeTaskStorageRecord(normalized.task);
+  }
+  return normalized;
+}
+
 /**
  * Generate sprint review report from archived tasks.
  * @param {object[]} archivedTasks

package/task/task-attachments.mjs

@@ -16,6 +16,11 @@ import {
   renameSync,
 } from "node:fs";
 import { resolveRepoRoot } from "../config/repo-root.mjs";
+import {
+  getTaskAttachmentCanonicalKey,
+  normalizeTaskAttachmentRecord,
+  normalizeTaskAttachments,
+} from "./task-store.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const TAG = "[task-attachments]";
@@ -70,17 +75,12 @@ function taskKey(taskId, backend) {
 }
 
 function attachmentKey(att) {
-  if (!att) return "";
-  if (att.url) return `url:${att.url}`;
-  if (att.filePath) return `file:${att.filePath}`;
-  if (att.path) return `path:${att.path}`;
-  if (att.id) return `id:${att.id}`;
-  return `raw:${JSON.stringify(att)}`;
+  return getTaskAttachmentCanonicalKey(att);
 }
 
 function normalizeAttachment(att, backend) {
-  if (!att || typeof att !== "object") return null;
-  const normalized = { ...att };
+  const normalized = normalizeTaskAttachmentRecord(att);
+  if (!normalized || typeof normalized !== "object") return null;
   if (!normalized.id) normalized.id = randomUUID();
   if (!normalized.createdAt) normalized.createdAt = nowIso();
   if (!normalized.source) normalized.source = "upload";
@@ -133,6 +133,11 @@ export function loadStore() {
     if (!_store || typeof _store !== "object") {
       _store = defaultStore();
     }
+    const tasks = _store.tasks && typeof _store.tasks === "object" ? _store.tasks : {};
+    for (const entry of Object.values(tasks)) {
+      if (!entry || typeof entry !== "object") continue;
+      entry.attachments = normalizeTaskAttachments(entry.attachments);
+    }
   } catch (err) {
     console.warn(`${TAG} failed to read store: ${err.message || err}`);
     _store = defaultStore();
@@ -162,7 +167,7 @@ export function listTaskAttachments(taskId, backend = "internal") {
   if (!key) return [];
   const entry = store.tasks?.[key];
   const attachments = Array.isArray(entry?.attachments) ? entry.attachments : [];
-  return attachments.slice();
+  return normalizeTaskAttachments(attachments);
 }
 
 export function addTaskAttachment(taskId, backend, attachment) {
@@ -184,4 +189,3 @@ export function addTaskAttachment(taskId, backend, attachment) {
   saveStore();
   return normalized;
 }
-

package/task/task-cli.mjs

@@ -306,8 +306,7 @@ function isDebugModeEnabled(args = []) {
  * Create a new task. Accepts a plain object with task fields.
  * Returns the created task or throws on error.
  */
-export async function taskCreate(data) {
-  const store = await initStore();
+function buildTaskInput(data, store) {
   const normalizeKey = store.normalizeWorkspaceStorageKey || normalizeStoreScopeKey;
   const normalizeKeys =
     store.normalizeWorkspaceStorageKeys
@@ -388,6 +387,22 @@ export async function taskCreate(data) {
     taskData.description = parts.join("\n");
   }
 
+  return taskData;
+}
+
+function buildImportedTaskInput(data, store) {
+  const taskData = buildTaskInput(data, store);
+  return {
+    ...data,
+    ...taskData,
+    meta: taskData.meta,
+  };
+}
+
+export async function taskCreate(data) {
+  const store = await initStore();
+  const taskData = buildTaskInput(data, store);
+
   const result = store.addTask(taskData);
   if (!result) {
     throw new Error(`Failed to create task — addTask returned null`);
@@ -1099,10 +1114,16 @@ export async function taskImport(source) {
   let created = 0;
   let failed = 0;
   const errors = [];
+  const store = await initStore();
 
   for (const t of tasks) {
     try {
-      await taskCreate(t);
+      const importedTask = buildImportedTaskInput(t, store);
+      const result = store.addTask(importedTask);
+      if (!result) {
+        throw new Error("Failed to create task — addTask returned null");
+      }
+      await flushStoreWrites(store);
       created++;
     } catch (err) {
       failed++;
@@ -1822,4 +1843,3 @@ if (process.argv[1] && resolve(process.argv[1]) === __filename) {
     process.exit(1);
   });
 }
-

package/task/task-executor.mjs

@@ -66,6 +66,7 @@ import {
 } from "./task-store.mjs";
 import { createErrorDetector } from "../infra/error-detector.mjs";
 import { getSessionTracker } from "../infra/session-tracker.mjs";
+import { addSpanLink } from "../infra/tracing.mjs";
 import {
   getCompactDiffSummary,
   getRecentCommits,
@@ -4365,6 +4366,24 @@ class TaskExecutor {
     };
   }
 
+  getTuiStats() {
+    const tokenTotals = Array.from(attemptTelemetry.values()).reduce((acc, telemetry) => {
+      acc.tokensIn += Math.max(0, Number(telemetry?.prompt_tokens || 0) || 0);
+      acc.tokensOut += Math.max(0, Number(telemetry?.completion_tokens || 0) || 0);
+      acc.tokensTotal += Math.max(0, Number(telemetry?.total_tokens || 0) || 0);
+      return acc;
+    }, { tokensIn: 0, tokensOut: 0, tokensTotal: 0 });
+
+    return {
+      activeAgents: this._activeSlots.size,
+      maxAgents: this.maxParallel,
+      tokensIn: tokenTotals.tokensIn,
+      tokensOut: tokenTotals.tokensOut,
+      tokensTotal: tokenTotals.tokensTotal || (tokenTotals.tokensIn + tokenTotals.tokensOut),
+      rateLimits: {},
+    };
+  }
+
   getBacklogReplenishmentConfig() {
     return {
       ...this._backlogReplenishment,