bosun 0.42.0 → 0.42.2

package/infra/tui-bridge.mjs

@@ -0,0 +1,415 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+export const TUI_EVENT_TYPES = Object.freeze([
+  "monitor:stats",
+  "sessions:update",
+  "session:event",
+  "logs:stream",
+  "workflow:status",
+  "tasks:update",
+]);
+
+const RATE_LIMIT_BUCKET_SCHEMA = {
+  type: "object",
+  required: ["primary", "secondary", "credits", "unit"],
+  additionalProperties: false,
+  properties: {
+    primary: { type: ["number", "null"] },
+    secondary: { type: ["number", "null"] },
+    credits: { type: ["number", "null"] },
+    unit: { type: "string", minLength: 1 },
+  },
+};
+
+const SESSION_SUMMARY_SCHEMA = {
+  type: "object",
+  required: [
+    "id",
+    "taskId",
+    "title",
+    "type",
+    "status",
+    "workspaceId",
+    "workspaceDir",
+    "branch",
+    "turnCount",
+    "createdAt",
+    "lastActiveAt",
+    "idleMs",
+    "elapsedMs",
+    "recommendation",
+    "preview",
+    "lastMessage",
+    "insights",
+  ],
+  additionalProperties: true,
+  properties: {
+    id: { type: "string", minLength: 1 },
+    taskId: { type: "string", minLength: 1 },
+    title: { type: ["string", "null"] },
+    type: { type: "string", minLength: 1 },
+    status: { type: "string", minLength: 1 },
+    workspaceId: { type: ["string", "null"] },
+    workspaceDir: { type: ["string", "null"] },
+    branch: { type: ["string", "null"] },
+    turnCount: { type: "number", minimum: 0 },
+    createdAt: { type: "string", minLength: 1 },
+    lastActiveAt: { type: "string", minLength: 1 },
+    idleMs: { type: "number", minimum: 0 },
+    elapsedMs: { type: "number", minimum: 0 },
+    recommendation: { type: "string" },
+    preview: { type: ["string", "null"] },
+    lastMessage: { type: ["string", "null"] },
+    insights: {},
+  },
+};
+
+export const TUI_EVENT_SCHEMAS = Object.freeze({
+  "monitor:stats": {
+    type: "object",
+    required: [
+      "activeAgents",
+      "maxAgents",
+      "tokensIn",
+      "tokensOut",
+      "tokensTotal",
+      "throughputTps",
+      "uptimeMs",
+      "rateLimits",
+    ],
+    additionalProperties: false,
+    properties: {
+      activeAgents: { type: "number", minimum: 0 },
+      maxAgents: { type: "number", minimum: 0 },
+      tokensIn: { type: "number", minimum: 0 },
+      tokensOut: { type: "number", minimum: 0 },
+      tokensTotal: { type: "number", minimum: 0 },
+      throughputTps: { type: "number", minimum: 0 },
+      uptimeMs: { type: "number", minimum: 0 },
+      rateLimits: {
+        type: "object",
+        additionalProperties: RATE_LIMIT_BUCKET_SCHEMA,
+      },
+    },
+  },
+  "sessions:update": {
+    type: "array",
+    items: SESSION_SUMMARY_SCHEMA,
+  },
+  "session:event": {
+    type: "object",
+    required: ["sessionId", "taskId", "session", "event"],
+    additionalProperties: false,
+    properties: {
+      sessionId: { type: "string", minLength: 1 },
+      taskId: { type: "string", minLength: 1 },
+      session: {
+        type: "object",
+        required: ["id", "taskId", "type", "status", "lastActiveAt", "turnCount"],
+        additionalProperties: true,
+        properties: {
+          id: { type: "string", minLength: 1 },
+          taskId: { type: "string", minLength: 1 },
+          type: { type: "string", minLength: 1 },
+          status: { type: "string", minLength: 1 },
+          lastActiveAt: { type: "string", minLength: 1 },
+          turnCount: { type: "number", minimum: 0 },
+        },
+      },
+      event: {
+        type: "object",
+        required: ["kind"],
+        additionalProperties: true,
+        properties: {
+          kind: { type: "string", enum: ["message", "state"] },
+        },
+      },
+    },
+  },
+  "logs:stream": {
+    type: "object",
+    required: ["logType", "raw", "line", "level", "timestamp", "filePath"],
+    additionalProperties: false,
+    properties: {
+      logType: { type: "string", minLength: 1 },
+      query: { type: ["string", "null"] },
+      filePath: { type: ["string", "null"] },
+      line: { type: "string" },
+      raw: { type: "string" },
+      level: { type: "string", minLength: 1 },
+      timestamp: { type: ["string", "null"] },
+    },
+  },
+  "workflow:status": {
+    type: "object",
+    required: ["runId", "workflowId", "eventType", "status", "timestamp"],
+    additionalProperties: false,
+    properties: {
+      runId: { type: "string", minLength: 1 },
+      workflowId: { type: "string", minLength: 1 },
+      workflowName: { type: ["string", "null"] },
+      eventType: { type: "string", minLength: 1 },
+      status: { type: "string", minLength: 1 },
+      nodeId: { type: ["string", "null"] },
+      nodeType: { type: ["string", "null"] },
+      nodeLabel: { type: ["string", "null"] },
+      error: { type: ["string", "null"] },
+      durationMs: { type: ["number", "null"], minimum: 0 },
+      timestamp: { type: "number", minimum: 0 },
+      meta: { type: ["object", "null"] },
+    },
+  },
+  "tasks:update": {
+    type: "object",
+    required: ["reason", "sourceEvent", "patch"],
+    additionalProperties: false,
+    properties: {
+      reason: { type: "string", minLength: 1 },
+      sourceEvent: { type: "string", minLength: 1 },
+      taskId: { type: ["string", "null"] },
+      taskIds: {
+        type: ["array", "null"],
+        items: { type: "string", minLength: 1 },
+      },
+      status: { type: ["string", "null"] },
+      workspaceId: { type: ["string", "null"] },
+      projectId: { type: ["string", "null"] },
+      patch: { type: "object", additionalProperties: true },
+    },
+  },
+});
+
+function numberOr(value, fallback = 0) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function nonNegativeNumber(value, fallback = 0) {
+  return Math.max(0, numberOr(value, fallback));
+}
+
+function roundMetric(value, precision = 4) {
+  const numeric = nonNegativeNumber(value, 0);
+  return Number(numeric.toFixed(precision));
+}
+
+function resolveCacheDir({ cacheDir, configDir } = {}) {
+  if (cacheDir) return resolve(String(cacheDir));
+  return resolve(String(configDir || process.cwd()), ".cache");
+}
+
+function normalizeRateLimits(rateLimits = {}) {
+  const normalized = {};
+  for (const [provider, bucket] of Object.entries(rateLimits || {})) {
+    const key = String(provider || "").trim();
+    if (!key || !bucket || typeof bucket !== "object") continue;
+    normalized[key] = {
+      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),
+      unit: String(bucket.unit || "count").trim() || "count",
+    };
+  }
+  return normalized;
+}
+
+function sumRuntimeTokens(runtimeStats = {}) {
+  const sessions = Array.isArray(runtimeStats?.sessions) ? runtimeStats.sessions : [];
+  return sessions.reduce((acc, session) => {
+    acc.tokensIn += nonNegativeNumber(session?.inputTokens, 0);
+    acc.tokensOut += nonNegativeNumber(session?.outputTokens, 0);
+    return acc;
+  }, { tokensIn: 0, tokensOut: 0 });
+}
+
+export function buildMonitorStatsPayload({ agentPool, runtimeStats = {}, uptimeMs = 0 } = {}) {
+  const agentPoolStats = typeof agentPool?.getTuiStats === "function"
+    ? (agentPool.getTuiStats() || {})
+    : (agentPool && typeof agentPool === "object" ? agentPool : {});
+
+  const runtimeTokenTotals = sumRuntimeTokens(runtimeStats);
+  const tokensIn = nonNegativeNumber(
+    agentPoolStats.tokensIn,
+    runtimeStats.totalInputTokens ?? runtimeTokenTotals.tokensIn,
+  );
+  const tokensOut = nonNegativeNumber(
+    agentPoolStats.tokensOut,
+    runtimeStats.totalOutputTokens ?? runtimeTokenTotals.tokensOut,
+  );
+  const tokensTotal = nonNegativeNumber(agentPoolStats.tokensTotal, tokensIn + tokensOut);
+  const resolvedUptimeMs = nonNegativeNumber(
+    uptimeMs,
+    runtimeStats.startedAt ? Date.now() - Number(runtimeStats.startedAt) : 0,
+  );
+  const throughputTps = Number.isFinite(Number(agentPoolStats.throughputTps))
+    ? roundMetric(agentPoolStats.throughputTps)
+    : (resolvedUptimeMs > 0 ? roundMetric(tokensTotal / (resolvedUptimeMs / 1000)) : 0);
+
+  return {
+    activeAgents: nonNegativeNumber(agentPoolStats.activeAgents, 0),
+    maxAgents: nonNegativeNumber(agentPoolStats.maxAgents, 0),
+    tokensIn,
+    tokensOut,
+    tokensTotal,
+    throughputTps,
+    uptimeMs: resolvedUptimeMs,
+    rateLimits: normalizeRateLimits(agentPoolStats.rateLimits),
+  };
+}
+
+export function buildSessionsUpdatePayload(sessions = []) {
+  return Array.isArray(sessions) ? sessions.map((session) => ({ ...session })) : [];
+}
+
+export function buildSessionEventPayload(payload = {}) {
+  const event = payload?.event && typeof payload.event === "object"
+    ? { ...payload.event }
+    : { kind: "message", ...(payload?.message ? { message: payload.message } : {}) };
+  return {
+    sessionId: String(payload?.sessionId || payload?.session?.id || "").trim(),
+    taskId: String(payload?.taskId || payload?.session?.taskId || "").trim(),
+    session: payload?.session && typeof payload.session === "object" ? { ...payload.session } : {},
+    event,
+  };
+}
+
+export function buildWorkflowStatusPayload(payload = {}) {
+  return {
+    runId: String(payload?.runId || "").trim(),
+    workflowId: String(payload?.workflowId || "").trim(),
+    workflowName: String(payload?.workflowName || payload?.name || "").trim() || null,
+    eventType: String(payload?.eventType || payload?.event || "").trim(),
+    status: String(payload?.status || "unknown").trim() || "unknown",
+    nodeId: String(payload?.nodeId || "").trim() || null,
+    nodeType: String(payload?.nodeType || "").trim() || null,
+    nodeLabel: String(payload?.nodeLabel || "").trim() || null,
+    error: String(payload?.error || "").trim() || null,
+    durationMs: Number.isFinite(Number(payload?.durationMs)) ? Number(payload.durationMs) : null,
+    timestamp: nonNegativeNumber(payload?.timestamp, Date.now()),
+    meta: payload?.meta && typeof payload.meta === "object" ? { ...payload.meta } : null,
+  };
+}
+
+export function buildLogStreamPayload({ logType, query = null, filePath = null, line = "" } = {}) {
+  const raw = String(line || "");
+  const levelMatch = raw.match(/\b(trace|debug|info|warn|warning|error|fatal)\b/i);
+  const timestampMatch = raw.match(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\b/);
+  return {
+    logType: String(logType || "system").trim() || "system",
+    query: query == null ? null : String(query),
+    filePath: filePath == null ? null : String(filePath),
+    line: raw,
+    raw,
+    level: levelMatch ? levelMatch[1].toLowerCase().replace("warning", "warn") : "info",
+    timestamp: timestampMatch ? timestampMatch[0] : null,
+  };
+}
+
+export function buildTasksUpdatePayload(payload = {}, { sourceEvent = "invalidate" } = {}) {
+  const normalized = payload && typeof payload === "object" ? payload : {};
+  const patch = normalized.patch && typeof normalized.patch === "object"
+    ? { ...normalized.patch }
+    : { ...normalized };
+  const reason = String(normalized.reason || sourceEvent || "tasks-changed").trim() || "tasks-changed";
+  const taskIds = Array.isArray(normalized.taskIds)
+    ? normalized.taskIds.map((taskId) => String(taskId || "").trim()).filter(Boolean)
+    : null;
+  return {
+    reason,
+    sourceEvent: String(sourceEvent || "invalidate").trim() || "invalidate",
+    taskId: String(normalized.taskId || normalized.id || "").trim() || null,
+    taskIds: taskIds && taskIds.length ? taskIds : null,
+    status: String(normalized.status || "").trim() || null,
+    workspaceId: String(normalized.workspaceId || "").trim() || null,
+    projectId: String(normalized.projectId || "").trim() || null,
+    patch,
+  };
+}
+
+export function resolveTuiAuthToken({ env = process.env, cacheDir, configDir = process.cwd() } = {}) {
+  const envCandidates = [
+    env?.BOSUN_TUI_AUTH_TOKEN,
+    env?.BOSUN_TUI_WS_TOKEN,
+    env?.BOSUN_UI_TOKEN,
+    env?.BOSUN_WS_TOKEN,
+  ];
+  for (const candidate of envCandidates) {
+    const token = String(candidate || "").trim();
+    if (token) return token;
+  }
+
+  const resolvedCacheDir = resolveCacheDir({ cacheDir, configDir });
+  const candidateFiles = [
+    resolve(resolvedCacheDir, "ui-token"),
+    resolve(resolvedCacheDir, "ui-session-token.json"),
+  ];
+  for (const filePath of candidateFiles) {
+    try {
+      if (!existsSync(filePath)) continue;
+      const raw = readFileSync(filePath, "utf8").trim();
+      if (!raw) continue;
+      if (raw.startsWith("{")) {
+        const parsed = JSON.parse(raw);
+        const token = String(parsed?.token || "").trim();
+        if (token) return token;
+        continue;
+      }
+      return raw;
+    } catch {
+      // ignore invalid cache files
+    }
+  }
+  return "";
+}
+
+export function persistCompatibleTuiAuthToken(token, { cacheDir, configDir = process.cwd() } = {}) {
+  const normalized = String(token || "").trim();
+  if (!normalized) return "";
+  const resolvedCacheDir = resolveCacheDir({ cacheDir, configDir });
+  mkdirSync(resolvedCacheDir, { recursive: true });
+  writeFileSync(resolve(resolvedCacheDir, "ui-token"), `${normalized}\n`, "utf8");
+  return normalized;
+}
+
+export function createTuiStatsEmitter({ intervalMs = 2000, getPayload, emit } = {}) {
+  let timer = null;
+  let inFlight = null;
+
+  const tick = async () => {
+    if (inFlight) return inFlight;
+    inFlight = Promise.resolve()
+      .then(() => (typeof getPayload === "function" ? getPayload() : null))
+      .then(async (payload) => {
+        if (payload && typeof emit === "function") {
+          await emit(payload);
+        }
+        return payload;
+      })
+      .finally(() => {
+        inFlight = null;
+      });
+    return inFlight;
+  };
+
+  return {
+    async tick() {
+      return tick();
+    },
+    start() {
+      if (timer) return;
+      timer = setInterval(() => {
+        void tick();
+      }, Math.max(250, Number(intervalMs) || 2000));
+      timer.unref?.();
+    },
+    stop() {
+      if (!timer) return;
+      clearInterval(timer);
+      timer = null;
+    },
+    get isRunning() {
+      return Boolean(timer);
+    },
+  };
+}

package/infra/worktree-recovery-state.mjs

@@ -0,0 +1,159 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+const DEFAULT_RECOVERY_STATE = Object.freeze({
+  health: "healthy",
+  failureStreak: 0,
+  failureCount: 0,
+  successCount: 0,
+  lastUpdatedAt: null,
+  lastFailureAt: null,
+  lastRecoveredAt: null,
+  lastHealthyAt: null,
+  recentEvents: Object.freeze([]),
+});
+
+const MAX_RECOVERY_EVENTS = 12;
+const VALID_HEALTH = new Set(["healthy", "recovered", "failing", "degraded"]);
+const VALID_OUTCOMES = new Set(["healthy_noop", "recreated", "recreation_failed"]);
+
+function getStatusPath(repoRoot) {
+  const override = String(process.env.STATUS_FILE || "").trim();
+  if (override) {
+    // If override is an absolute path, resolve it directly;
+    // if it's relative, resolve it against the repo root.
+    const isWindowsAbsolute = /^[a-zA-Z]:[\\/]/.test(override) || override.startsWith("\\\\");
+    const isPosixAbsolute = override.startsWith("/");
+    if (isWindowsAbsolute || isPosixAbsolute) {
+      return resolve(override);
+    }
+    return resolve(repoRoot, override);
+  }
+  return resolve(repoRoot, ".cache", "ve-orchestrator-status.json");
+}
+
+function toIsoTimestamp(value) {
+  const text = String(value || "").trim();
+  if (!text) return new Date().toISOString();
+  const parsed = new Date(text);
+  return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : new Date().toISOString();
+}
+
+function normalizeDetectedIssues(input) {
+  const values = Array.isArray(input) ? input : [input];
+  const seen = new Set();
+  const issues = [];
+  for (const value of values) {
+    const normalized = String(value || "").trim();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    issues.push(normalized);
+  }
+  return issues;
+}
+
+function normalizeRecoveryEvent(event = {}) {
+  const outcome = String(event?.outcome || "").trim().toLowerCase();
+  return {
+    outcome: VALID_OUTCOMES.has(outcome) ? outcome : "healthy_noop",
+    reason: String(event?.reason || "").trim() || null,
+    branch: String(event?.branch || "").trim() || null,
+    taskId: String(event?.taskId || "").trim() || null,
+    worktreePath: String(event?.worktreePath || "").trim() || null,
+    phase: String(event?.phase || "").trim() || null,
+    error: String(event?.error || "").trim() || null,
+    detectedIssues: normalizeDetectedIssues(event?.detectedIssues),
+    timestamp: toIsoTimestamp(event?.timestamp),
+  };
+}
+
+function normalizeWorktreeRecoveryState(input = null) {
+  const source = input && typeof input === "object" ? input : {};
+  const health = String(source.health || "").trim().toLowerCase();
+  return {
+    health: VALID_HEALTH.has(health) ? health : "healthy",
+    failureStreak: Math.max(0, Number.parseInt(String(source.failureStreak || 0), 10) || 0),
+    failureCount: Math.max(0, Number.parseInt(String(source.failureCount || 0), 10) || 0),
+    successCount: Math.max(0, Number.parseInt(String(source.successCount || 0), 10) || 0),
+    lastUpdatedAt: source.lastUpdatedAt ? toIsoTimestamp(source.lastUpdatedAt) : null,
+    lastFailureAt: source.lastFailureAt ? toIsoTimestamp(source.lastFailureAt) : null,
+    lastRecoveredAt: source.lastRecoveredAt ? toIsoTimestamp(source.lastRecoveredAt) : null,
+    lastHealthyAt: source.lastHealthyAt ? toIsoTimestamp(source.lastHealthyAt) : null,
+    recentEvents: Array.isArray(source.recentEvents)
+      ? source.recentEvents.map((event) => normalizeRecoveryEvent(event)).slice(0, MAX_RECOVERY_EVENTS)
+      : [],
+  };
+}
+
+function buildNextWorktreeRecoveryState(currentState, event) {
+  const state = normalizeWorktreeRecoveryState(currentState);
+  const normalizedEvent = normalizeRecoveryEvent(event);
+  const nextState = {
+    ...state,
+    lastUpdatedAt: normalizedEvent.timestamp,
+  };
+
+  if (normalizedEvent.outcome === "healthy_noop") {
+    return {
+      ...nextState,
+      health: state.failureStreak > 0 ? state.health : "healthy",
+      lastHealthyAt: normalizedEvent.timestamp,
+    };
+  }
+
+  const recentEvents = [normalizedEvent, ...state.recentEvents].slice(0, MAX_RECOVERY_EVENTS);
+  if (normalizedEvent.outcome === "recreated") {
+    return {
+      ...nextState,
+      health: "recovered",
+      failureStreak: 0,
+      successCount: state.successCount + 1,
+      lastRecoveredAt: normalizedEvent.timestamp,
+      lastHealthyAt: normalizedEvent.timestamp,
+      recentEvents,
+    };
+  }
+
+  const failureStreak = state.failureStreak + 1;
+  return {
+    ...nextState,
+    health: failureStreak > 1 ? "degraded" : "failing",
+    failureStreak,
+    failureCount: state.failureCount + 1,
+    lastFailureAt: normalizedEvent.timestamp,
+    recentEvents,
+  };
+}
+
+async function readStatusDocument(repoRoot) {
+  const statusPath = getStatusPath(repoRoot);
+  try {
+    const raw = await readFile(statusPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+async function readWorktreeRecoveryState(repoRoot) {
+  const document = await readStatusDocument(repoRoot);
+  return normalizeWorktreeRecoveryState(document.worktreeRecovery);
+}
+
+async function recordWorktreeRecoveryEvent(repoRoot, event) {
+  const statusPath = getStatusPath(repoRoot);
+  const document = await readStatusDocument(repoRoot);
+  document.worktreeRecovery = buildNextWorktreeRecoveryState(document.worktreeRecovery, event);
+  await mkdir(dirname(statusPath), { recursive: true });
+  await writeFile(statusPath, JSON.stringify(document, null, 2), "utf8");
+  return document.worktreeRecovery;
+}
+
+export {
+  buildNextWorktreeRecoveryState,
+  normalizeRecoveryEvent,
+  normalizeWorktreeRecoveryState,
+  readWorktreeRecoveryState,
+  recordWorktreeRecoveryEvent,
+};

package/kanban/kanban-adapter.mjs

@@ -137,6 +137,23 @@ function normaliseStatus(raw) {
   return STATUS_MAP[key] || "todo";
 }
 
+function resolveCreateTaskInput(projectIdOrTaskData, taskDataArg = {}) {
+  const payloadOnlyCall =
+    projectIdOrTaskData &&
+    typeof projectIdOrTaskData === "object" &&
+    !Array.isArray(projectIdOrTaskData);
+  const rawTaskData = payloadOnlyCall ? projectIdOrTaskData : (taskDataArg || {});
+  const projectId = payloadOnlyCall
+    ? rawTaskData?.projectId ?? rawTaskData?.project_id
+    : projectIdOrTaskData;
+  const {
+    projectId: _ignoredProjectId,
+    project_id: _ignoredProjectIdSnake,
+    ...taskData
+  } = rawTaskData || {};
+  return { projectId, taskData };
+}
+
 const STATUS_LABEL_KEYS = new Set([
   "draft",
   "todo",
@@ -1008,7 +1025,11 @@ class InternalAdapter {
     return this._normalizeTask(updated);
   }
 
-  async createTask(projectId, taskData = {}) {
+  async createTask(projectIdOrTaskData, taskDataArg = {}) {
+    const { projectId, taskData } = resolveCreateTaskInput(
+      projectIdOrTaskData,
+      taskDataArg,
+    );
     const id = String(taskData.id || randomUUID());
     const tags = normalizeTags(taskData.tags || taskData.labels || []);
     const draft = Boolean(taskData.draft || taskData.status === "draft");
@@ -1551,7 +1572,11 @@ class VKAdapter {
     return this._normaliseTask(task);
   }
 
-  async createTask(projectId, taskData) {
+  async createTask(projectIdOrTaskData, taskDataArg = {}) {
+    const { projectId, taskData } = resolveCreateTaskInput(
+      projectIdOrTaskData,
+      taskDataArg,
+    );
     const fetchVk = await this._getFetchVk();
     const tags = normalizeTags(taskData?.tags || taskData?.labels || []);
     const draft = Boolean(taskData?.draft || taskData?.status === "draft");
@@ -3617,7 +3642,8 @@ class GitHubIssuesAdapter {
     return result?.data?.convertProjectV2DraftIssueItemToIssue?.issue || null;
   }
 
-  async createTask(_projectId, taskData) {
+  async createTask(projectIdOrTaskData, taskDataArg = {}) {
+    const { taskData } = resolveCreateTaskInput(projectIdOrTaskData, taskDataArg);
     const normalizedTitle = String(taskData?.title || "").trim();
     if (!normalizedTitle) {
       throw new Error("[kanban] github createTask requires non-empty title");
@@ -5417,7 +5443,11 @@ class JiraAdapter {
     return this.getTask(issueKey);
   }
 
-  async createTask(projectId, taskData = {}) {
+  async createTask(projectIdOrTaskData, taskDataArg = {}) {
+    const { projectId, taskData } = resolveCreateTaskInput(
+      projectIdOrTaskData,
+      taskDataArg,
+    );
     const projectKey = this._normalizeProjectKey(projectId);
     if (!projectKey) {
       throw new Error(
@@ -6082,12 +6112,16 @@ export async function updateTask(taskId, patch) {
   return adapter.getTask(taskId);
 }
 
-export async function createTask(projectId, taskData) {
+export async function createTask(projectIdOrTaskData, taskDataArg = {}) {
+  const { projectId, taskData } = resolveCreateTaskInput(
+    projectIdOrTaskData,
+    taskDataArg,
+  );
   const result = await getKanbanAdapter().createTask(projectId, taskData);
   emitKanbanEvent("task.created", {
-    projectId,
+    projectId: projectId ?? result?.projectId ?? result?.project_id ?? null,
     taskId: result?.id || null,
-    title: taskData?.title || null,
+    title: taskData?.title ?? result?.title ?? null,
   });
   return result;
 }
@@ -6164,4 +6198,3 @@ export async function unmarkTaskIgnored(taskId) {
   );
   return false;
 }
-