bosun 0.40.0 → 0.40.2

package/agent/primary-agent.mjs

@@ -741,6 +741,114 @@ const FALLBACK_ORDER = [
   "opencode-sdk",
 ];
 
+const FAILOVER_CONSECUTIVE_INFRA_ERRORS = Math.max(
+  1,
+  Number(process.env.PRIMARY_AGENT_FAILOVER_CONSECUTIVE_INFRA_ERRORS) || 3,
+);
+const FAILOVER_ERROR_WINDOW_MS = Math.max(
+  10_000,
+  Number(process.env.PRIMARY_AGENT_FAILOVER_ERROR_WINDOW_MS) ||
+    10 * 60 * 1000,
+);
+const _primaryRecoveryRetryEnv = Number(
+  process.env.PRIMARY_AGENT_RECOVERY_RETRY_ATTEMPTS,
+);
+const PRIMARY_RECOVERY_RETRY_ATTEMPTS = Number.isFinite(
+  _primaryRecoveryRetryEnv,
+)
+  ? Math.max(0, _primaryRecoveryRetryEnv)
+  : 1;
+
+const _adapterFailureState = new Map();
+
+function adapterErrorText(err) {
+  const message = String(err?.message || err || "");
+  const code = String(err?.code || "");
+  return `${code} ${message}`.trim();
+}
+
+function isSessionScopedAdapterError(err) {
+  const text = adapterErrorText(err).toLowerCase();
+  if (!text) return false;
+  return (
+    /\b(session|thread|conversation|context)\b.*\b(not found|expired|invalid|closed|corrupt)\b/.test(
+      text,
+    ) ||
+    /\bfailed to resume session\b/.test(text) ||
+    /\bsession does not exist\b/.test(text)
+  );
+}
+
+function isInfrastructureAdapterError(err) {
+  const text = adapterErrorText(err).toLowerCase();
+  if (!text) return false;
+  return (
+    /\bagent_timeout\b/.test(text) ||
+    /\bcodex exec exited with code\b/.test(text) ||
+    /\btransport channel closed\b/.test(text) ||
+    /\bstream disconnected\b/.test(text) ||
+    /\brate limit|too many requests|429\b/.test(text) ||
+    /\bservice unavailable|temporarily unavailable|overloaded\b/.test(text) ||
+    /\bcannot find module\b/.test(text) ||
+    /\bsdk not available|failed to load sdk\b/.test(text) ||
+    /\beconnreset|econnrefused|etimedout|network error\b/.test(text) ||
+    /\bsegfault|crash|killed\b/.test(text)
+  );
+}
+
+function clearAdapterFailureState(adapterName) {
+  if (!adapterName) return;
+  _adapterFailureState.delete(adapterName);
+}
+
+function noteAdapterFailure(adapterName, err) {
+  const now = Date.now();
+  const infrastructure = isInfrastructureAdapterError(err);
+  const previous = _adapterFailureState.get(adapterName) || {
+    streak: 0,
+    lastAt: 0,
+    lastError: "",
+    infrastructure: false,
+  };
+
+  const next = {
+    streak: 0,
+    lastAt: now,
+    lastError: adapterErrorText(err),
+    infrastructure,
+  };
+
+  if (infrastructure) {
+    const withinWindow =
+      now - Number(previous.lastAt || 0) <= FAILOVER_ERROR_WINDOW_MS;
+    next.streak =
+      withinWindow && previous.infrastructure ? previous.streak + 1 : 1;
+  }
+
+  _adapterFailureState.set(adapterName, next);
+  return {
+    ...next,
+    allowFailover:
+      infrastructure && next.streak >= FAILOVER_CONSECUTIVE_INFRA_ERRORS,
+  };
+}
+
+async function recoverAdapterSession(adapter, adapterName) {
+  if (!adapter) return;
+  if (typeof adapter.reset === "function") {
+    try {
+      await adapter.reset();
+    } catch (err) {
+      console.warn(
+        `[primary-agent] recovery reset failed for ${adapterName}: ${err?.message || err}`,
+      );
+    }
+  }
+  if (typeof adapter.init === "function") {
+    await adapter.init();
+  }
+}
+
 function mapAdapterToPoolSdk(adapterName) {
   const normalized = String(adapterName || "").trim().toLowerCase();
   if (normalized === "copilot-sdk") return "copilot";
@@ -875,8 +983,12 @@ export async function execPrimaryPrompt(userMessage, options = {}) {
   }
 
   let lastError = null;
+  const maxAdaptersToTry = Math.min(
+    adaptersToTry.length,
+    maxFailoverAttempts + 1,
+  );
 
-  for (let attempt = 0; attempt < Math.min(adaptersToTry.length, maxFailoverAttempts + 1); attempt++) {
+  for (let attempt = 0; attempt < maxAdaptersToTry; attempt++) {
     const adapterName = adaptersToTry[attempt];
     const adapter = ADAPTERS[adapterName];
     if (!adapter) continue;
@@ -950,16 +1062,96 @@ export async function execPrimaryPrompt(userMessage, options = {}) {
           });
         }
       }
+      clearAdapterFailureState(adapterName);
       return result;
     } catch (err) {
       lastError = err;
       const isTimeout = err.message?.startsWith("AGENT_TIMEOUT");
+      const isPrimaryAttempt = attempt === 0;
       console.error(
         `[primary-agent] ${isTimeout ? ":clock: Timeout" : ":close: Error"} with ${adapterName}: ${err.message}`,
       );
 
+      if (
+        isPrimaryAttempt &&
+        PRIMARY_RECOVERY_RETRY_ATTEMPTS > 0 &&
+        (isSessionScopedAdapterError(err) || isInfrastructureAdapterError(err))
+      ) {
+        for (let retry = 1; retry <= PRIMARY_RECOVERY_RETRY_ATTEMPTS; retry++) {
+          try {
+            console.warn(
+              `[primary-agent] :arrows_counterclockwise: recovering ${adapterName} session (${retry}/${PRIMARY_RECOVERY_RETRY_ATTEMPTS})`,
+            );
+            tracker.recordEvent(sessionId, {
+              role: "system",
+              type: "recovery",
+              content: `:arrows_counterclockwise: Recovering ${adapterName} session (${retry}/${PRIMARY_RECOVERY_RETRY_ATTEMPTS}) before any failover.`,
+              timestamp: new Date().toISOString(),
+            });
+            await recoverAdapterSession(adapter, adapterName);
+            const timeoutAbort = new AbortController();
+            if (options.abortController?.signal) {
+              const callerSignal = options.abortController.signal;
+              if (callerSignal.aborted) {
+                timeoutAbort.abort(callerSignal.reason);
+              } else {
+                callerSignal.addEventListener("abort", () => {
+                  timeoutAbort.abort(callerSignal.reason || "user_stop");
+                }, { once: true });
+              }
+            }
+            const retryResult = await withTimeout(
+              adapter.exec(framedMessage, { ...options, sessionId, abortController: timeoutAbort }),
+              timeoutMs,
+              `${adapterName}.exec.retry`,
+              timeoutAbort,
+            );
+            const retryText = typeof retryResult === "string"
+              ? retryResult
+              : retryResult.finalResponse || retryResult.text || retryResult.message || JSON.stringify(retryResult);
+            tracker.recordEvent(sessionId, {
+              role: "assistant",
+              content: retryText,
+              timestamp: new Date().toISOString(),
+              _sessionType: sessionType,
+            });
+            clearAdapterFailureState(adapterName);
+            return retryResult;
+          } catch (retryErr) {
+            lastError = retryErr;
+            console.error(
+              `[primary-agent] :close: recovery attempt ${retry}/${PRIMARY_RECOVERY_RETRY_ATTEMPTS} failed for ${adapterName}: ${retryErr?.message || retryErr}`,
+            );
+          }
+        }
+      }
+
+      const failureState = noteAdapterFailure(adapterName, lastError);
+      const shouldBlockPrimaryFailover =
+        isPrimaryAttempt && !failureState.allowFailover;
+
+      if (shouldBlockPrimaryFailover) {
+        const waitReason = failureState.infrastructure
+          ? `holding failover until ${FAILOVER_CONSECUTIVE_INFRA_ERRORS} consecutive infrastructure failures (${failureState.streak}/${FAILOVER_CONSECUTIVE_INFRA_ERRORS})`
+          : "error classified as session-scoped/non-infrastructure";
+        console.warn(
+          `[primary-agent] failover suppressed for ${adapterName}: ${waitReason}`,
+        );
+        tracker.recordEvent(sessionId, {
+          role: "system",
+          type: "error",
+          content: `:warning: ${adapterName} error: ${lastError?.message || "unknown error"}. Failover suppressed (${waitReason}).`,
+          timestamp: new Date().toISOString(),
+        });
+        return {
+          finalResponse: `:warning: ${adapterName} error: ${lastError?.message || "unknown error"}. Failover suppressed (${waitReason}).`,
+          items: [],
+          usage: null,
+        };
+      }
+
       // If this is the last adapter, report to user
-      if (attempt >= Math.min(adaptersToTry.length, maxFailoverAttempts + 1) - 1) {
+      if (attempt >= maxAdaptersToTry - 1) {
         tracker.recordEvent(sessionId, {
           role: "system",
           type: "error",

package/config/config-doctor.mjs

@@ -39,6 +39,7 @@ function detectRepoRoot() {
     return execSync("git rev-parse --show-toplevel", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"],
+      timeout: 1500,
     }).trim();
   } catch {
     return process.cwd();
@@ -144,8 +145,12 @@ function mergeNoOverride(base, extra) {
 function commandExists(command) {
   try {
     const checker = process.platform === "win32" ? "where" : "which";
-    spawnSync(checker, [command], { stdio: "ignore" });
-    return true;
+    const result = spawnSync(checker, [command], {
+      stdio: "ignore",
+      timeout: 1500,
+      windowsHide: true,
+    });
+    return result.status === 0;
   } catch {
     return false;
   }
@@ -982,3 +987,5 @@ export function formatWorkspaceHealthReport(result) {
 
   return lines.join("\n");
 }
+
+

package/config/config.mjs

@@ -658,6 +658,12 @@ function detectRepoSlug(repoRoot = "") {
 }
 
 function detectRepoRoot() {
+  const gitExecOptions = {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "ignore"],
+    timeout: 3000,
+  };
+
   // 1. Explicit env var
   if (process.env.REPO_ROOT) {
     const envRoot = resolve(process.env.REPO_ROOT);
@@ -667,8 +673,7 @@ function detectRepoRoot() {
   // 2. Try git from cwd
   try {
     const gitRoot = execSync("git rev-parse --show-toplevel", {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "ignore"],
+      ...gitExecOptions,
     }).trim();
     if (gitRoot) return gitRoot;
   } catch {
@@ -678,9 +683,8 @@ function detectRepoRoot() {
   // 3. Bosun package directory may be inside a repo (common: scripts/bosun/ within a project)
   try {
     const gitRoot = execSync("git rev-parse --show-toplevel", {
-      encoding: "utf8",
       cwd: __dirname,
-      stdio: ["pipe", "pipe", "ignore"],
+      ...gitExecOptions,
     }).trim();
     if (gitRoot) return gitRoot;
   } catch {
@@ -693,9 +697,8 @@ function detectRepoRoot() {
   if (moduleRoot && moduleRoot !== process.cwd()) {
     try {
       const gitRoot = execSync("git rev-parse --show-toplevel", {
-        encoding: "utf8",
         cwd: moduleRoot,
-        stdio: ["pipe", "pipe", "ignore"],
+        ...gitExecOptions,
       }).trim();
       if (gitRoot) return gitRoot;
     } catch {
@@ -1285,20 +1288,27 @@ export function loadConfig(argv = process.argv, options = {}) {
 
   const { reloadEnv = false } = options;
   const cli = parseArgs(argv);
+  const repoRootOverride = cli["repo-root"] || process.env.REPO_ROOT || "";
+  const normalizedRepoRootOverride = repoRootOverride
+    ? resolve(repoRootOverride)
+    : "";
+  let detectedRepoRoot = "";
+  const getFallbackRepoRoot = () => {
+    if (normalizedRepoRootOverride) return normalizedRepoRootOverride;
+    if (!detectedRepoRoot) detectedRepoRoot = detectRepoRoot();
+    return detectedRepoRoot;
+  };
 
-  const repoRootForConfig = detectRepoRoot();
   // Determine config directory (where bosun stores its config)
   const configDir =
     cli["config-dir"] ||
     process.env.BOSUN_DIR ||
-    resolveConfigDir(repoRootForConfig);
+    resolveConfigDir(normalizedRepoRootOverride);
 
   const configFile = loadConfigFile(configDir);
   let configData = configFile.data || {};
   const configFileHadInvalidJson = configFile.error === "invalid-json";
 
-  const repoRootOverride = cli["repo-root"] || process.env.REPO_ROOT || "";
-
   // Load workspace configuration
   const workspacesDir = resolve(configDir, "workspaces");
   const activeWorkspace = cli["workspace"] ||
@@ -1340,7 +1350,8 @@ export function loadConfig(argv = process.argv, options = {}) {
   // over REPO_ROOT (env); REPO_ROOT becomes "developer root" for config only.
   const selectedRepoPath = selectedRepository?.path || "";
   const selectedRepoHasGit = selectedRepoPath && existsSync(resolve(selectedRepoPath, ".git"));
-  let repoRoot = (selectedRepoHasGit ? selectedRepoPath : null) || repoRootOverride || detectRepoRoot();
+  let repoRoot =
+    (selectedRepoHasGit ? selectedRepoPath : null) || getFallbackRepoRoot();
 
   // Resolve agent execution root (workspace-aware, separate from developer root)
   const agentRepoRoot = resolveAgentRepoRoot();
@@ -1405,7 +1416,7 @@ export function loadConfig(argv = process.argv, options = {}) {
   {
     const selPath = selectedRepository?.path || "";
     const selHasGit = selPath && existsSync(resolve(selPath, ".git"));
-    repoRoot = (selHasGit ? selPath : null) || repoRootOverride || detectRepoRoot();
+    repoRoot = (selHasGit ? selPath : null) || getFallbackRepoRoot();
   }
 
   if (resolve(repoRoot) !== resolve(initialRepoRoot)) {

package/infra/session-tracker.mjs

@@ -14,6 +14,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { buildSessionInsights } from "../lib/session-insights.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SESSIONS_DIR = resolve(__dirname, "..", "logs", "sessions");
@@ -184,6 +185,7 @@ export class SessionTracker {
       status: "active",
       lastActivityAt: Date.now(),
       metadata: {},
+      insights: buildSessionInsights({ messages: [] }),
     });
     this.#markDirty(taskId);
   }
@@ -235,6 +237,7 @@ export class SessionTracker {
       if (Number.isFinite(maxMessages) && maxMessages > 0) {
         while (session.messages.length > maxMessages) session.messages.shift();
       }
+      this.#refreshDerivedState(session);
       this.#markDirty(taskId);
       emitSessionEvent(session, msg);
       return;
@@ -266,6 +269,7 @@ export class SessionTracker {
       if (Number.isFinite(maxMessages) && maxMessages > 0) {
         while (session.messages.length > maxMessages) session.messages.shift();
       }
+      this.#refreshDerivedState(session);
       this.#markDirty(taskId);
       emitSessionEvent(session, msg);
       return;
@@ -282,6 +286,7 @@ export class SessionTracker {
     if (Number.isFinite(maxMessages) && maxMessages > 0) {
       while (session.messages.length > maxMessages) session.messages.shift();
     }
+    this.#refreshDerivedState(session);
     this.#markDirty(taskId);
     emitSessionEvent(session, msg);
   }
@@ -297,6 +302,7 @@ export class SessionTracker {
 
     session.endedAt = Date.now();
     session.status = status;
+    this.#refreshDerivedState(session);
     this.#markDirty(taskId);
   }
 
@@ -521,6 +527,7 @@ export class SessionTracker {
       lastActivityAt: Date.now(),
       metadata,
       maxMessages: resolvedMax,
+      insights: buildSessionInsights({ messages: [] }),
     };
     this.#sessions.set(id, session);
     this.#markDirty(id);
@@ -549,6 +556,7 @@ export class SessionTracker {
         lastActiveAt: s.lastActiveAt || new Date(s.lastActivityAt).toISOString(),
         preview: this.#lastMessagePreview(s),
         lastMessage: this.#lastMessagePreview(s),
+        insights: s.insights || null,
       });
     }
     list.sort((a, b) => (b.lastActiveAt || "").localeCompare(a.lastActiveAt || ""));
@@ -587,6 +595,7 @@ export class SessionTracker {
     if (status === "completed" || status === "archived") {
       session.endedAt = Date.now();
     }
+    this.#refreshDerivedState(session);
     this.#markDirty(sessionId);
   }
 
@@ -665,6 +674,7 @@ export class SessionTracker {
     target.editedAt = new Date().toISOString();
     session.lastActivityAt = Date.now();
     session.lastActiveAt = new Date().toISOString();
+    this.#refreshDerivedState(session);
     this.#markDirty(sessionId);
 
     return { ok: true, message: { ...target }, index: idx };
@@ -766,6 +776,7 @@ export class SessionTracker {
         status,
         lastActivityAt: lastActive || Date.now(),
         metadata: data.metadata || {},
+        insights: data.insights || buildSessionInsights({ messages: data.messages || [] }),
       });
     }
   }
@@ -817,6 +828,7 @@ export class SessionTracker {
       if (idleMs > this.#idleThresholdMs) {
         session.status = "completed";
         session.endedAt = now;
+        this.#refreshDerivedState(session);
         this.#markDirty(id);
         reaped++;
       }
@@ -840,6 +852,18 @@ export class SessionTracker {
     }
   }
 
+  #refreshDerivedState(session) {
+    if (!session) return;
+    try {
+      session.insights = buildSessionInsights({
+        ...session,
+        insights: null,
+      });
+    } catch {
+      // Inspector insights are best-effort only.
+    }
+  }
+
   #ensureDir() {
     if (this.#persistDir && !existsSync(this.#persistDir)) {
       mkdirSync(this.#persistDir, { recursive: true });
@@ -872,6 +896,7 @@ export class SessionTracker {
           turnCount: session.turnCount || 0,
           messages: session.messages || [],
           metadata: session.metadata || {},
+          insights: session.insights || null,
         };
         writeFileSync(filePath, JSON.stringify(data, null, 2));
       } catch (err) {
@@ -946,6 +971,7 @@ export class SessionTracker {
           turnCount: data.turnCount || 0,
           lastActivityAt: lastActive || Date.now(),
           metadata: data.metadata || {},
+          insights: data.insights || buildSessionInsights({ messages: data.messages || [] }),
         });
       }
     } catch {

package/kanban/kanban-adapter.mjs

@@ -744,6 +744,16 @@ class InternalAdapter {
       ? task.meta.comments
       : [];
     const normalizedComments = normalizeCommentList(rawComments);
+    const assignee = normalizeTaskStringField(resolveTaskField(task, "assignee"));
+    const assignees = normalizeTaskStringList(
+      resolveTaskField(task, "assignees", assignee ? [assignee] : []),
+    );
+    const epicId = normalizeTaskStringField(resolveTaskField(task, "epicId"));
+    const storyPoints = normalizeTaskNumericField(resolveTaskField(task, "storyPoints"));
+    const parentTaskId = normalizeTaskStringField(
+      resolveTaskField(task, "parentTaskId"),
+    );
+    const dueDate = normalizeTaskStringField(resolveTaskField(task, "dueDate"));
     const existingAttachments = []
       .concat(Array.isArray(task.attachments) ? task.attachments : [])
       .concat(Array.isArray(task.meta?.attachments) ? task.meta.attachments : []);
@@ -757,7 +767,12 @@ class InternalAdapter {
       title: recoveredTitle || "",
       description,
       status: normaliseStatus(task.status || recoveredStatus),
-      assignee: task.assignee || null,
+      assignee: assignee || assignees[0] || null,
+      assignees,
+      epicId,
+      storyPoints,
+      parentTaskId,
+      dueDate,
       priority: task.priority || null,
       tags,
       draft,
@@ -862,6 +877,20 @@ class InternalAdapter {
     if (typeof patch.workspace === "string") updates.workspace = patch.workspace;
     if (typeof patch.repository === "string") updates.repository = patch.repository;
     if (Array.isArray(patch.repositories)) updates.repositories = patch.repositories;
+    const assigneeProvided = hasOwnField(patch, "assignee");
+    const assigneesProvided = hasOwnField(patch, "assignees");
+    const assignee = normalizeTaskStringField(patch.assignee ?? patch.meta?.assignee);
+    const assignees = normalizeTaskStringList(
+      assigneesProvided
+        ? patch.assignees
+        : patch.meta?.assignees ?? (assignee ? [assignee] : []),
+    );
+    const epicId = normalizeTaskStringField(patch.epicId ?? patch.meta?.epicId);
+    const storyPoints = normalizeTaskNumericField(patch.storyPoints ?? patch.meta?.storyPoints);
+    const parentTaskId = normalizeTaskStringField(
+      patch.parentTaskId ?? patch.meta?.parentTaskId,
+    );
+    const dueDate = normalizeTaskStringField(patch.dueDate ?? patch.meta?.dueDate);
     if (Array.isArray(patch.tags) || Array.isArray(patch.labels) || typeof patch.tags === "string") {
       updates.tags = normalizeTags(patch.tags ?? patch.labels);
     }
@@ -875,10 +904,32 @@ class InternalAdapter {
     if (baseBranch) {
       updates.baseBranch = baseBranch;
     }
+    if (assigneeProvided || assignee || assignees.length > 0) {
+      updates.assignee = assignee || assignees[0] || null;
+      updates.assignees = assignees.length > 0 ? assignees : assignee ? [assignee] : [];
+    }
+    if (hasOwnField(patch, "epicId") || epicId) updates.epicId = epicId;
+    if (hasOwnField(patch, "storyPoints") || storyPoints != null) {
+      updates.storyPoints = storyPoints;
+    }
+    if (hasOwnField(patch, "parentTaskId") || parentTaskId) {
+      updates.parentTaskId = parentTaskId;
+    }
+    if (hasOwnField(patch, "dueDate") || dueDate) updates.dueDate = dueDate;
     if (patch.meta && typeof patch.meta === "object") {
       updates.meta = {
         ...(current?.meta || {}),
         ...patch.meta,
+        ...((assigneeProvided || assignee || assignees.length > 0)
+          ? {
+            assignee: assignee || assignees[0] || null,
+            assignees: assignees.length > 0 ? assignees : assignee ? [assignee] : [],
+          }
+          : {}),
+        ...((hasOwnField(patch, "epicId") || epicId) ? { epicId } : {}),
+        ...((hasOwnField(patch, "storyPoints") || storyPoints != null) ? { storyPoints } : {}),
+        ...((hasOwnField(patch, "parentTaskId") || parentTaskId) ? { parentTaskId } : {}),
+        ...((hasOwnField(patch, "dueDate") || dueDate) ? { dueDate } : {}),
         ...(typeof patch.workspace === "string" ? { workspace: patch.workspace } : {}),
         ...(typeof patch.repository === "string" ? { repository: patch.repository } : {}),
         ...(Array.isArray(patch.repositories) ? { repositories: patch.repositories } : {}),
@@ -903,12 +954,29 @@ class InternalAdapter {
     const tags = normalizeTags(taskData.tags || taskData.labels || []);
     const draft = Boolean(taskData.draft || taskData.status === "draft");
     const baseBranch = resolveBaseBranchInput(taskData);
+    const assignee = normalizeTaskStringField(taskData.assignee ?? taskData.meta?.assignee);
+    const assignees = normalizeTaskStringList(
+      taskData.assignees ?? taskData.meta?.assignees ?? (assignee ? [assignee] : []),
+    );
+    const epicId = normalizeTaskStringField(taskData.epicId ?? taskData.meta?.epicId);
+    const storyPoints = normalizeTaskNumericField(
+      taskData.storyPoints ?? taskData.meta?.storyPoints,
+    );
+    const parentTaskId = normalizeTaskStringField(
+      taskData.parentTaskId ?? taskData.meta?.parentTaskId,
+    );
+    const dueDate = normalizeTaskStringField(taskData.dueDate ?? taskData.meta?.dueDate);
     const created = addInternalTask({
       id,
       title: taskData.title || "Untitled task",
       description: taskData.description || "",
       status: draft ? "draft" : normaliseStatus(taskData.status || "todo"),
-      assignee: taskData.assignee || null,
+      assignee: assignee || assignees[0] || null,
+      assignees,
+      epicId,
+      storyPoints,
+      parentTaskId,
+      dueDate,
       priority: taskData.priority || null,
       tags,
       draft,
@@ -932,6 +1000,16 @@ class InternalAdapter {
       baseBranch,
       meta: {
         ...(taskData.meta || {}),
+        ...((assignee || assignees.length > 0)
+          ? {
+            assignee: assignee || assignees[0] || null,
+            assignees: assignees.length > 0 ? assignees : assignee ? [assignee] : [],
+          }
+          : {}),
+        ...(epicId ? { epicId } : {}),
+        ...(storyPoints != null ? { storyPoints } : {}),
+        ...(parentTaskId ? { parentTaskId } : {}),
+        ...(dueDate ? { dueDate } : {}),
         ...(taskData.workspace ? { workspace: taskData.workspace } : {}),
         ...(taskData.repository || taskData.repo
           ? { repository: taskData.repository || taskData.repo }
@@ -1004,6 +1082,43 @@ function normalizeTags(raw) {
   return normalizeLabels(raw);
 }
 
+function hasOwnField(value, key) {
+  return Object.prototype.hasOwnProperty.call(value || {}, key);
+}
+
+function normalizeTaskStringField(value) {
+  const normalized = String(value || "").trim();
+  return normalized || null;
+}
+
+function normalizeTaskStringList(value) {
+  const values = Array.isArray(value)
+    ? value
+    : typeof value === "string"
+      ? value.split(",")
+      : [];
+  const seen = new Set();
+  const normalized = [];
+  for (const entry of values) {
+    const next = normalizeTaskStringField(entry?.login || entry?.name || entry);
+    if (!next || seen.has(next)) continue;
+    seen.add(next);
+    normalized.push(next);
+  }
+  return normalized;
+}
+
+function normalizeTaskNumericField(value) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+
+function resolveTaskField(task, key, fallback = null) {
+  if (task?.[key] != null) return task[key];
+  if (task?.meta?.[key] != null) return task.meta[key];
+  return fallback;
+}
+
 function looksLikeKanbanEntity(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   return (