@sideboard-ai/core 0.1.326 → 0.1.328

package/dist/{chunk-Q3FHTGIW.js → chunk-5Y2C7Q55.js}

@@ -4,16 +4,24 @@ import {
   cursorSdkStoreDir
 } from "./chunk-WMZIANPV.js";
 import {
-  normalizeThinkingEffort
-} from "./chunk-KGZBYWZ3.js";
+  caffeinateWhileSchedulesEnabled,
+  coerceOrchestratorAgent,
+  isOrchestratorCapableAgent,
+  normalizeThinkingEffort,
+  updateAdvancedSettings
+} from "./chunk-EJRCHCXM.js";
 import {
+  writePrivateFile
+} from "./chunk-NSTQ6QKD.js";
+import {
+  appDataDir,
   threadFilePath,
   threadLockPath,
   threadsDir
 } from "./chunk-WOU343SI.js";
 
 // src/store/thread-store.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/review/review-write-gate.ts
 var REVIEW_TAB_TITLE = "Review";
@@ -961,8 +969,8 @@ function isWorktreeIdentityTitle(title, identities) {
 
 // src/store/thread-store.ts
 import {
-  existsSync,
-  readFileSync,
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
   renameSync,
   rmSync,
   statSync,
@@ -1008,7 +1016,8 @@ var BASE_ALLOWED_TOOLS = [
   "TaskStop",
   "EnterWorktree",
   "ExitWorktree",
-  "Skill"
+  "Skill",
+  "AskUserQuestion"
 ];
 var CLAUDE_PRINT_BG_WAIT_CEILING_MS = 72e5;
 var CLAUDE_CHROME_ALLOWED_TOOLS = [
@@ -1021,8 +1030,412 @@ var CLAUDE_POSTHOG_CONNECTOR_ALLOWED_TOOLS = [
   "mcp__claude_ai_PostHog__*"
 ];
 
+// src/store/schedules.ts
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// src/store/schedule-when.ts
+import { Cron } from "croner";
+var DURATION_RE = /^(\d+)(s|m|h|d)$/i;
+var UNIT_MS = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+var DAY_ALIASES = {
+  sun: 0,
+  sunday: 0,
+  mon: 1,
+  monday: 1,
+  tue: 2,
+  tues: 2,
+  tuesday: 2,
+  wed: 3,
+  wednesday: 3,
+  thu: 4,
+  thur: 4,
+  thurs: 4,
+  thursday: 4,
+  fri: 5,
+  friday: 5,
+  sat: 6,
+  saturday: 6
+};
+var TIME_RE = /^([01]\d|2[0-3]):([0-5]\d)(?::[0-5]\d)?$/;
+function parseDurationMs(every) {
+  const m = every.trim().match(DURATION_RE);
+  if (!m) return null;
+  const n = Number.parseInt(m[1], 10);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = m[2].toLowerCase();
+  return n * UNIT_MS[unit];
+}
+function dayIndex(token) {
+  const text = token.trim().toLowerCase();
+  if (/^[0-6]$/.test(text)) return Number(text);
+  return DAY_ALIASES[text];
+}
+function normalizeWeekdays(days) {
+  const set = /* @__PURE__ */ new Set();
+  for (const day of days) {
+    if (!Number.isInteger(day) || day < 0 || day > 6) {
+      throw new Error("Days must be 0 (Sunday) through 6 (Saturday)");
+    }
+    set.add(day);
+  }
+  if (set.size === 0) throw new Error("Pick at least one day");
+  return [...set].sort((a, b) => a - b);
+}
+function parseWeeklyDays(raw) {
+  const text = raw.trim().toLowerCase();
+  if (!text) throw new Error("Pick at least one day");
+  if (text === "daily" || text === "all" || text === "every day" || text === "everyday") {
+    return [0, 1, 2, 3, 4, 5, 6];
+  }
+  if (text === "weekdays" || text === "weekday") return [1, 2, 3, 4, 5];
+  if (text === "weekends" || text === "weekend") return [0, 6];
+  const days = [];
+  for (const part of text.split(/[\s,]+/).filter(Boolean)) {
+    const range = part.split("-");
+    if (range.length === 2 && range[0] && range[1]) {
+      const start = dayIndex(range[0]);
+      const end = dayIndex(range[1]);
+      if (start === void 0 || end === void 0) {
+        throw new Error(`Unknown day: ${part} (use mon,tue, weekdays, weekends, or daily)`);
+      }
+      if (start <= end) {
+        for (let d = start; d <= end; d++) days.push(d);
+      } else {
+        for (let d = start; d <= 6; d++) days.push(d);
+        for (let d = 0; d <= end; d++) days.push(d);
+      }
+      continue;
+    }
+    const n = dayIndex(part);
+    if (n === void 0) {
+      throw new Error(`Unknown day: ${part} (use mon,tue, weekdays, weekends, or daily)`);
+    }
+    days.push(n);
+  }
+  return normalizeWeekdays(days);
+}
+function normalizeWeeklyTime(raw) {
+  const m = raw.trim().match(TIME_RE);
+  if (!m) throw new Error(`Invalid time: ${raw} (use HH:mm, 24-hour)`);
+  return `${m[1]}:${m[2]}`;
+}
+function weeklyCronExpr(when) {
+  const time = normalizeWeeklyTime(when.time);
+  const [hh, mm] = time.split(":");
+  const days = normalizeWeekdays(when.days);
+  return `${Number(mm)} ${Number(hh)} * * ${days.join(",")}`;
+}
+function computeNextRunAt(when, from = /* @__PURE__ */ new Date()) {
+  if (when.kind === "once") {
+    const at = new Date(when.at);
+    if (Number.isNaN(at.getTime())) {
+      throw new Error(`Invalid once-at datetime: ${when.at}`);
+    }
+    return at;
+  }
+  if (when.kind === "every") {
+    const ms = parseDurationMs(when.every);
+    if (!ms) {
+      throw new Error(`Invalid interval: ${when.every} (use 15m, 1h, 6h, 1d)`);
+    }
+    return new Date(from.getTime() + ms);
+  }
+  if (when.kind === "weekly") {
+    return computeNextRunAt(
+      { kind: "cron", expr: weeklyCronExpr(when), tz: when.tz },
+      from
+    );
+  }
+  try {
+    const job = new Cron(when.expr, {
+      timezone: when.tz?.trim() || void 0,
+      paused: true
+    });
+    const next = job.nextRun(from);
+    if (!next) {
+      throw new Error(`Cron expression has no next run: ${when.expr}`);
+    }
+    return next;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid cron: ${message}`);
+  }
+}
+function normalizeWhen(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("Schedule is missing `when`");
+  }
+  const rec = raw;
+  const kind = rec.kind;
+  if (kind === "once" && typeof rec.at === "string") {
+    return { kind: "once", at: rec.at };
+  }
+  if (kind === "every" && typeof rec.every === "string") {
+    return { kind: "every", every: rec.every };
+  }
+  if (kind === "cron" && typeof rec.expr === "string") {
+    return {
+      kind: "cron",
+      expr: rec.expr,
+      tz: typeof rec.tz === "string" && rec.tz.trim() ? rec.tz.trim() : void 0
+    };
+  }
+  if (kind === "weekly" && Array.isArray(rec.days) && typeof rec.time === "string") {
+    return {
+      kind: "weekly",
+      days: normalizeWeekdays(rec.days.map((day) => Number(day))),
+      time: normalizeWeeklyTime(rec.time),
+      tz: typeof rec.tz === "string" && rec.tz.trim() ? rec.tz.trim() : void 0
+    };
+  }
+  throw new Error("Schedule `when` must be once, every, weekly, or cron");
+}
+
+// src/store/schedules.ts
+function schedulesPath() {
+  return join(appDataDir(), "schedules.json");
+}
+function defaultScheduleName(prompt) {
+  const line = prompt.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
+  if (!line) return "Untitled automation";
+  return line.length > 60 ? `${line.slice(0, 57).trimEnd()}\u2026` : line;
+}
+function resolveScheduleThreadId(raw, env = process.env) {
+  const value = raw?.trim() || "";
+  if (!value) return null;
+  if (value.toLowerCase() === "self") {
+    return env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || env.SIDEBOARD_THREAD_ID?.trim() || null;
+  }
+  return value;
+}
+function nowIso(d = /* @__PURE__ */ new Date()) {
+  return d.toISOString();
+}
+var ATTACHMENT_KINDS = /* @__PURE__ */ new Set([
+  "transcript",
+  "file",
+  "issue",
+  "workspace",
+  "diff-comment",
+  "code-ref"
+]);
+function normalizeOptionalBool(raw) {
+  if (raw === true || raw === false) return raw;
+  return null;
+}
+function normalizeAutonomy(raw) {
+  return raw === "default" || raw === "full" ? raw : null;
+}
+function normalizeAttachments(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const row = item;
+    if (typeof row.id !== "string" || !row.id.trim()) continue;
+    if (typeof row.name !== "string" || !row.name) continue;
+    if (typeof row.content !== "string") continue;
+    if (!ATTACHMENT_KINDS.has(row.kind)) continue;
+    const next = {
+      id: row.id,
+      name: row.name,
+      kind: row.kind,
+      content: row.content
+    };
+    if (typeof row.path === "string" && row.path) next.path = row.path;
+    if (typeof row.previewDataUrl === "string" && row.previewDataUrl) {
+      next.previewDataUrl = row.previewDataUrl;
+    }
+    out.push(next);
+  }
+  return out;
+}
+function normalizeTask(raw) {
+  const when = normalizeWhen(raw.when);
+  const agent = raw.agent && isOrchestratorCapableAgent(raw.agent) ? raw.agent : null;
+  return {
+    id: raw.id,
+    name: typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : defaultScheduleName(raw.prompt),
+    prompt: String(raw.prompt ?? ""),
+    enabled: Boolean(raw.enabled),
+    when,
+    threadId: raw.threadId?.trim() || null,
+    agent,
+    model: raw.model?.trim() || null,
+    effort: normalizeThinkingEffort(raw.effort),
+    fast: normalizeOptionalBool(raw.fast),
+    planMode: normalizeOptionalBool(raw.planMode),
+    autonomy: normalizeAutonomy(raw.autonomy),
+    attachments: normalizeAttachments(raw.attachments),
+    archiveChat: raw.archiveChat !== false,
+    nextRunAt: raw.nextRunAt,
+    lastRunAt: raw.lastRunAt ?? null,
+    lastThreadId: raw.lastThreadId ?? null,
+    lastError: raw.lastError ?? null,
+    createdBy: raw.createdBy === "mcp" || raw.createdBy === "cli" || raw.createdBy === "ui" ? raw.createdBy : "ui",
+    createdAt: raw.createdAt,
+    updatedAt: raw.updatedAt
+  };
+}
+function readAll() {
+  const path = schedulesPath();
+  if (!existsSync(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!Array.isArray(parsed)) return [];
+    return parsed.map((row) => {
+      try {
+        return normalizeTask(row);
+      } catch {
+        return null;
+      }
+    }).filter((row) => Boolean(row?.id && row.prompt));
+  } catch {
+    return [];
+  }
+}
+function writeAll(rows) {
+  writePrivateFile(schedulesPath(), `${JSON.stringify(rows, null, 2)}
+`);
+}
+function buildTask(input, now) {
+  const prompt = input.prompt.trim();
+  if (!prompt) throw new Error("Schedule prompt is required");
+  const when = normalizeWhen(input.when);
+  const nextRunAt = computeNextRunAt(when, now).toISOString();
+  const ts = nowIso(now);
+  const agent = input.agent ? coerceOrchestratorAgent(input.agent) : null;
+  return {
+    id: randomUUID(),
+    name: input.name?.trim() || defaultScheduleName(prompt),
+    prompt,
+    enabled: input.enabled !== false,
+    when,
+    threadId: input.threadId?.trim() || null,
+    agent,
+    model: input.model?.trim() || null,
+    effort: input.effort != null ? normalizeThinkingEffort(input.effort) : null,
+    fast: normalizeOptionalBool(input.fast),
+    planMode: normalizeOptionalBool(input.planMode),
+    autonomy: normalizeAutonomy(input.autonomy),
+    attachments: normalizeAttachments(input.attachments),
+    archiveChat: input.archiveChat !== false,
+    nextRunAt,
+    lastRunAt: null,
+    lastThreadId: null,
+    lastError: null,
+    createdBy: input.createdBy,
+    createdAt: ts,
+    updatedAt: ts
+  };
+}
+function listSchedules() {
+  return readAll().sort((a, b) => a.nextRunAt.localeCompare(b.nextRunAt));
+}
+function scheduleNeedsCaffeinate(task, now = /* @__PURE__ */ new Date()) {
+  if (!task.enabled) return false;
+  const at = new Date(task.nextRunAt);
+  if (Number.isNaN(at.getTime())) return false;
+  return at.getTime() > now.getTime();
+}
+function ensureCaffeinateForFutureSchedule(task) {
+  if (!scheduleNeedsCaffeinate(task)) return;
+  if (caffeinateWhileSchedulesEnabled()) return;
+  updateAdvancedSettings({ caffeinateWhileSchedules: true });
+}
+function getSchedule(id) {
+  const key = id.trim();
+  if (!key) return null;
+  return readAll().find(
+    (row) => row.id === key || row.id.startsWith(key) && key.length >= 8
+  ) ?? null;
+}
+function createSchedule(input) {
+  const task = buildTask(input, /* @__PURE__ */ new Date());
+  const rows = readAll();
+  rows.push(task);
+  writeAll(rows);
+  ensureCaffeinateForFutureSchedule(task);
+  return task;
+}
+function updateSchedule(id, patch) {
+  const rows = readAll();
+  const idx = rows.findIndex((row) => row.id === id || id.length >= 8 && row.id.startsWith(id));
+  if (idx < 0) throw new Error(`Automation not found: ${id}`);
+  const prev = rows[idx];
+  const when = patch.when ? normalizeWhen(patch.when) : prev.when;
+  const prompt = patch.prompt !== void 0 ? patch.prompt.trim() : prev.prompt;
+  if (!prompt) throw new Error("Schedule prompt is required");
+  const whenChanged = patch.when !== void 0;
+  const next = {
+    ...prev,
+    name: patch.name !== void 0 ? patch.name.trim() || defaultScheduleName(prompt) : prev.name,
+    prompt,
+    enabled: patch.enabled ?? prev.enabled,
+    when,
+    threadId: patch.threadId !== void 0 ? patch.threadId?.trim() || null : prev.threadId,
+    agent: patch.agent !== void 0 ? patch.agent ? coerceOrchestratorAgent(patch.agent) : null : prev.agent,
+    model: patch.model !== void 0 ? patch.model?.trim() || null : prev.model,
+    effort: patch.effort !== void 0 ? normalizeThinkingEffort(patch.effort) : prev.effort,
+    fast: patch.fast !== void 0 ? normalizeOptionalBool(patch.fast) : prev.fast,
+    planMode: patch.planMode !== void 0 ? normalizeOptionalBool(patch.planMode) : prev.planMode,
+    autonomy: patch.autonomy !== void 0 ? normalizeAutonomy(patch.autonomy) : prev.autonomy,
+    attachments: patch.attachments !== void 0 ? normalizeAttachments(patch.attachments) : prev.attachments,
+    archiveChat: patch.archiveChat !== void 0 ? patch.archiveChat !== false : prev.archiveChat,
+    nextRunAt: whenChanged ? computeNextRunAt(when).toISOString() : prev.nextRunAt,
+    lastError: whenChanged ? null : prev.lastError,
+    updatedAt: nowIso()
+  };
+  rows[idx] = next;
+  writeAll(rows);
+  ensureCaffeinateForFutureSchedule(next);
+  return next;
+}
+function deleteSchedulesForThread(threadId) {
+  const id = threadId.trim();
+  if (!id) return;
+  const rows = readAll();
+  const next = rows.filter((row) => row.threadId !== id);
+  if (next.length === rows.length) return;
+  writeAll(next);
+}
+function deleteSchedule(id) {
+  const rows = readAll();
+  const next = rows.filter(
+    (row) => row.id !== id && !(id.length >= 8 && row.id.startsWith(id))
+  );
+  if (next.length === rows.length) throw new Error(`Automation not found: ${id}`);
+  writeAll(next);
+}
+function recordScheduleRun(id, result) {
+  const rows = readAll();
+  const idx = rows.findIndex((row) => row.id === id);
+  if (idx < 0) throw new Error(`Automation not found: ${id}`);
+  const prev = rows[idx];
+  const firedAt = result.firedAt ?? /* @__PURE__ */ new Date();
+  const next = {
+    ...prev,
+    enabled: prev.when.kind === "once" ? false : prev.enabled,
+    nextRunAt: prev.when.kind === "once" ? prev.nextRunAt : computeNextRunAt(prev.when, firedAt).toISOString(),
+    lastRunAt: nowIso(firedAt),
+    lastThreadId: result.lastThreadId !== void 0 ? result.lastThreadId : prev.lastThreadId,
+    lastError: result.lastError ?? null,
+    updatedAt: nowIso(firedAt)
+  };
+  rows[idx] = next;
+  writeAll(rows);
+  return next;
+}
+
 // src/store/thread-store.ts
-function nowIso() {
+function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function resolveThreadEffort(raw) {
@@ -1111,9 +1524,9 @@ function normalizeThread(raw) {
   };
 }
 function createEmptyThread(partial) {
-  const ts = nowIso();
+  const ts = nowIso2();
   return {
-    id: randomUUID(),
+    id: randomUUID2(),
     sessionId: partial.sessionId ?? null,
     autonomy: partial.autonomy ?? "default",
     model: partial.model ?? null,
@@ -1221,7 +1634,7 @@ function readThread(id) {
   const cache = cacheForDir();
   const cached = cache.byId.get(id);
   if (cached && cache.mtimeMs.get(id) === mtimeMs) return cached;
-  const raw = readFileSync(path, "utf8");
+  const raw = readFileSync2(path, "utf8");
   const thread = normalizeThread(JSON.parse(raw));
   rememberThread(thread, mtimeMs);
   return thread;
@@ -1230,7 +1643,7 @@ var selfWriteMtimes = /* @__PURE__ */ new Map();
 function writeThread(thread, opts) {
   const path = threadFilePath(idPath(thread.id));
   const tmp = `${path}.${process.pid}.tmp`;
-  const next = opts?.touch === false ? { ...thread } : { ...thread, updatedAt: nowIso() };
+  const next = opts?.touch === false ? { ...thread } : { ...thread, updatedAt: nowIso2() };
   writeFileSync(tmp, JSON.stringify(next, null, 2), "utf8");
   renameSync(tmp, path);
   const mtimeMs = fileMtimeMs(path) ?? Date.now();
@@ -1274,30 +1687,29 @@ function listThreads(opts) {
 function deleteThreadRecord(id) {
   forgetThread(id);
   const path = threadFilePath(id);
-  if (existsSync(path)) unlinkSync(path);
-  const lock = threadLockPath(id);
-  if (existsSync(lock)) {
-    try {
-      unlinkSync(lock);
-    } catch {
-    }
+  if (existsSync2(path)) unlinkSync(path);
+  try {
+    if (existsSync2(threadLockPath(id))) unlinkSync(threadLockPath(id));
+  } catch {
   }
   try {
     rmSync(cursorSdkStoreDir(id), { recursive: true, force: true });
   } catch {
   }
+  deleteSchedulesForThread(id);
 }
 function updateThread(id, patch) {
   const current = readThread(id);
   if (!current) throw new Error(`Thread not found: ${id}`);
-  const next = { ...current, ...patch, id: current.id, updatedAt: nowIso() };
+  const next = { ...current, ...patch, id: current.id, updatedAt: nowIso2() };
   if (next.status === "archived") {
-    next.archivedAt = typeof next.archivedAt === "string" && next.archivedAt.trim() || current.archivedAt || nowIso();
+    next.archivedAt = typeof next.archivedAt === "string" && next.archivedAt.trim() || current.archivedAt || nowIso2();
   } else {
     delete next.archivedAt;
   }
   if (!next.ephemeralAutomationId?.trim()) delete next.ephemeralAutomationId;
   writeThread(next);
+  if (patch.status === "archived" && current.status !== "archived") deleteSchedulesForThread(current.id);
   return next;
 }
 function appendMessage(id, message) {
@@ -1345,6 +1757,15 @@ export {
   CLAUDE_PRINT_BG_WAIT_CEILING_MS,
   CLAUDE_CHROME_ALLOWED_TOOLS,
   CLAUDE_POSTHOG_CONNECTOR_ALLOWED_TOOLS,
+  parseWeeklyDays,
+  resolveScheduleThreadId,
+  listSchedules,
+  scheduleNeedsCaffeinate,
+  getSchedule,
+  createSchedule,
+  updateSchedule,
+  deleteSchedule,
+  recordScheduleRun,
   resolveThreadEffort,
   normalizeThread,
   createEmptyThread,

package/dist/{chunk-TMCK5TLA.js → chunk-ATQLP22S.js}

@@ -2,7 +2,7 @@
 var LIST_TIMEOUT_MS = 15e3;
 async function listAssignedLinearIssues(opts) {
   try {
-    const { listLinearIssuesDirect } = await import("./linear-Z2T4KUAQ.js");
+    const { listLinearIssuesDirect } = await import("./linear-WLDCJ3AF.js");
     const listed = listLinearIssuesDirect({ limit: 50 }).catch(() => []);
     let timer;
     try {

package/dist/{chunk-PB6HW7SA.js → chunk-CHYUUETG.js}

@@ -10,13 +10,13 @@ import {
 import {
   abletimeRestUrl,
   textFromAbleTimeDoc
-} from "./chunk-KXRF6RNL.js";
+} from "./chunk-EUIVQAPK.js";
 import {
   assertAbleTimeCredential,
   callAbleTimeTool,
   normalizeAbleTimeHost,
   rewriteAbleTimeError
-} from "./chunk-C7HUCBX7.js";
+} from "./chunk-DACWFN4O.js";
 import {
   httpFetch
 } from "./chunk-JAT3JFOS.js";
@@ -25,7 +25,7 @@ import {
   getAbleTimeHost,
   isAbleTimeConnected,
   saveAbleTimeConnection
-} from "./chunk-QPSKQP6E.js";
+} from "./chunk-D446IWPP.js";
 
 // src/integrations/abletime-attachments.ts
 function asRecord(value) {

package/dist/{chunk-QPSKQP6E.js → chunk-D446IWPP.js}

@@ -1,6 +1,3 @@
-import {
-  normalizeThinkingEffort
-} from "./chunk-77WWLBCI.js";
 import {
   stripNestedElectronEnv
 } from "./chunk-4TR3HZFT.js";
@@ -53,6 +50,48 @@ function coerceOrchestratorAgent(agent, fallback = "claude") {
   return isOrchestratorCapableAgent(agent) ? agent : fallback;
 }
 
+// src/types/thinking-effort.ts
+var THINKING_EFFORTS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var EFFORT_SET = new Set(THINKING_EFFORTS);
+function normalizeThinkingEffort(value) {
+  if (typeof value !== "string") return null;
+  const v = value.trim().toLowerCase();
+  if (v === "normal") return "medium";
+  if (EFFORT_SET.has(v)) return v;
+  return null;
+}
+function isThinkingEffort(value) {
+  return typeof value === "string" && EFFORT_SET.has(value.trim().toLowerCase());
+}
+function nextThinkingEffort(current) {
+  const i = THINKING_EFFORTS.indexOf(current);
+  return THINKING_EFFORTS[(i + 1) % THINKING_EFFORTS.length];
+}
+function thinkingEffortBars(effort) {
+  const i = THINKING_EFFORTS.indexOf(effort);
+  return i >= 0 ? i + 1 : 3;
+}
+function thinkingEffortLabel(effort) {
+  switch (effort) {
+    case "low":
+      return "Low";
+    case "medium":
+      return "Medium";
+    case "high":
+      return "High";
+    case "xhigh":
+      return "Extra High";
+    case "max":
+      return "Max";
+  }
+}
+
 // src/store/thread-option-defaults.ts
 function normalizeAutonomy(value) {
   return value === "default" || value === "full" ? value : void 0;
@@ -2583,6 +2622,12 @@ function harnessEnvKey(harness) {
 }
 
 export {
+  THINKING_EFFORTS,
+  normalizeThinkingEffort,
+  isThinkingEffort,
+  nextThinkingEffort,
+  thinkingEffortBars,
+  thinkingEffortLabel,
   ORCHESTRATOR_AGENT_KINDS,
   isOrchestratorCapableAgent,
   assertOrchestratorCapableAgent,

package/dist/{chunk-C7HUCBX7.js → chunk-DACWFN4O.js}

@@ -4,7 +4,7 @@ import {
 import {
   getAbleTimeHost,
   isAbleTimeConnected
-} from "./chunk-QPSKQP6E.js";
+} from "./chunk-D446IWPP.js";
 
 // src/integrations/abletime-mcp.ts
 var DEFAULT_ABLETIME_HOST = "https://track.abletime.com";
@@ -153,7 +153,7 @@ function textsFromUnknown(value) {
   return "";
 }
 async function abletimeMcpRequest(method, params, opts) {
-  const rawToken = opts?.token ?? await import("./abletime-oauth-OYGS2DAU.js").then((m) => m.ensureAbleTimeAccessToken());
+  const rawToken = opts?.token ?? await import("./abletime-oauth-KWQQRHOQ.js").then((m) => m.ensureAbleTimeAccessToken());
   if (!rawToken?.trim()) {
     throw new Error("AbleTime is not connected \u2014 paste a personal access token in Account settings");
   }
@@ -224,9 +224,9 @@ async function callAbleTimeTool(name, args = {}, opts) {
   if (!opts?.token && !isAbleTimeConnected()) {
     throw new Error("AbleTime is not connected \u2014 paste a personal access token in Account settings");
   }
-  const rawToken = opts?.token ?? await import("./abletime-oauth-OYGS2DAU.js").then((m) => m.ensureAbleTimeAccessToken());
+  const rawToken = opts?.token ?? await import("./abletime-oauth-KWQQRHOQ.js").then((m) => m.ensureAbleTimeAccessToken());
   if (rawToken && ableTimeUsesRest(rawToken)) {
-    const { callAbleTimeRestTool } = await import("./abletime-rest-BKYKNPTC.js");
+    const { callAbleTimeRestTool } = await import("./abletime-rest-UJ6SXDBN.js");
     return callAbleTimeRestTool(name, args, { ...opts, token: rawToken });
   }
   const requestOpts = { ...opts, pm: opts?.pm ?? abletimeToolUsesPm(name) };
@@ -242,7 +242,7 @@ async function callAbleTimeTool(name, args = {}, opts) {
       return await call();
     }
     if (rawToken && ableTimeUsesRest(rawToken) && isAbleTimeRejectedCredential(message)) {
-      const { callAbleTimeRestTool } = await import("./abletime-rest-BKYKNPTC.js");
+      const { callAbleTimeRestTool } = await import("./abletime-rest-UJ6SXDBN.js");
       return callAbleTimeRestTool(name, args, { ...opts, token: rawToken });
     }
     throw err instanceof Error ? new Error(rewriteAbleTimeError(err.message)) : err;