@sideboard-ai/core 0.1.258 → 0.1.261

package/dist/{abletime-IDQJI2KW.js → abletime-CDGINDXG.js}

@@ -15,16 +15,17 @@ import {
   toAbleTimeIssueInfo,
   updateAbleTimeTask,
   verifyAbleTimeConnection
-} from "./chunk-CPEIHTG7.js";
-import "./chunk-66LAOKLK.js";
-import "./chunk-IFHHPPSL.js";
+} from "./chunk-KVQX62XI.js";
+import "./chunk-D554YCHG.js";
+import "./chunk-J6ONZP74.js";
 import "./chunk-N7WZ6NIN.js";
-import "./chunk-KJM3E3NF.js";
+import "./chunk-6PFZ6XO7.js";
+import "./chunk-4TR3HZFT.js";
 import "./chunk-WDRMZKVB.js";
+import "./chunk-3HO2OY5T.js";
 import "./chunk-JT7R45JB.js";
 import "./chunk-77WWLBCI.js";
 import "./chunk-EHT2DRT4.js";
-import "./chunk-4TR3HZFT.js";
 export {
   ableTimeDependencyTarget,
   commentAbleTimeTask,

package/dist/{abletime-OGQR4LIL.js → abletime-OQ4PC52L.js}

@@ -17,16 +17,17 @@ import {
   toAbleTimeIssueInfo,
   updateAbleTimeTask,
   verifyAbleTimeConnection
-} from "./chunk-RTQOCFIV.js";
-import "./chunk-XIEDFRBP.js";
-import "./chunk-ZC3TVLY6.js";
+} from "./chunk-S7VDDJ34.js";
+import "./chunk-B6XFBNYM.js";
+import "./chunk-5OKJDCBK.js";
 import "./chunk-VKQGAWHY.js";
-import "./chunk-452Y24PW.js";
+import "./chunk-VIC6TDYT.js";
 import "./chunk-NSTQ6QKD.js";
-import "./chunk-KGZBYWZ3.js";
-import "./chunk-Z2LGMV6C.js";
 import "./chunk-WWUABK6B.js";
 import "./chunk-FJZWM2ON.js";
+import "./chunk-CEMNIGQH.js";
+import "./chunk-KGZBYWZ3.js";
+import "./chunk-Z2LGMV6C.js";
 export {
   ableTimeDependencyTarget,
   commentAbleTimeTask,

package/dist/{abletime-oauth-ZQUIY4EM.js → abletime-oauth-5A5EOH2A.js}

@@ -20,15 +20,16 @@ import {
   parseAbleTimeOAuthCallbackUrl,
   resolveAbleTimeOAuthHost,
   startAbleTimeOAuth
-} from "./chunk-FGWUZOZN.js";
-import "./chunk-IFHHPPSL.js";
+} from "./chunk-YFTO7U2A.js";
+import "./chunk-J6ONZP74.js";
 import "./chunk-N7WZ6NIN.js";
-import "./chunk-KJM3E3NF.js";
+import "./chunk-6PFZ6XO7.js";
+import "./chunk-4TR3HZFT.js";
 import "./chunk-WDRMZKVB.js";
+import "./chunk-3HO2OY5T.js";
 import "./chunk-JT7R45JB.js";
 import "./chunk-77WWLBCI.js";
 import "./chunk-EHT2DRT4.js";
-import "./chunk-4TR3HZFT.js";
 export {
   ABLETIME_OAUTH_CALLBACK_PATH,
   ABLETIME_OAUTH_CANCELLED,

package/dist/{abletime-oauth-MBAG5MYU.js → abletime-oauth-KX2TDFTE.js}

@@ -3,7 +3,7 @@
 import {
   DEFAULT_ABLETIME_HOST,
   normalizeAbleTimeHost
-} from "./chunk-ZC3TVLY6.js";
+} from "./chunk-5OKJDCBK.js";
 import {
   httpFetch
 } from "./chunk-VKQGAWHY.js";
@@ -12,12 +12,13 @@ import {
   getAbleTimeHost,
   loadAppSettings,
   saveAbleTimeConnection
-} from "./chunk-452Y24PW.js";
+} from "./chunk-VIC6TDYT.js";
 import "./chunk-NSTQ6QKD.js";
-import "./chunk-KGZBYWZ3.js";
-import "./chunk-Z2LGMV6C.js";
 import "./chunk-WWUABK6B.js";
 import "./chunk-FJZWM2ON.js";
+import "./chunk-CEMNIGQH.js";
+import "./chunk-KGZBYWZ3.js";
+import "./chunk-Z2LGMV6C.js";
 
 // src/integrations/abletime-oauth.ts
 import { createHash, randomBytes } from "crypto";
@@ -287,7 +288,7 @@ async function startAbleTimeOAuth(opts) {
   persistAbleTimeTokens(data, { host });
   const token = data.access_token.trim();
   try {
-    const { getAbleTimeOrientation } = await import("./abletime-OGQR4LIL.js");
+    const { getAbleTimeOrientation } = await import("./abletime-OQ4PC52L.js");
     const orientation = await getAbleTimeOrientation({ token, host });
     return saveAbleTimeConnection({
       accessToken: token,

package/dist/{abletime-rest-WEJERY4O.js → abletime-rest-PUGKYTRR.js}

@@ -7,15 +7,16 @@ import {
   callAbleTimeRestTool,
   looksLikeAbleTimeUlid,
   textFromAbleTimeDoc
-} from "./chunk-XIEDFRBP.js";
-import "./chunk-ZC3TVLY6.js";
+} from "./chunk-B6XFBNYM.js";
+import "./chunk-5OKJDCBK.js";
 import "./chunk-VKQGAWHY.js";
-import "./chunk-452Y24PW.js";
+import "./chunk-VIC6TDYT.js";
 import "./chunk-NSTQ6QKD.js";
-import "./chunk-KGZBYWZ3.js";
-import "./chunk-Z2LGMV6C.js";
 import "./chunk-WWUABK6B.js";
 import "./chunk-FJZWM2ON.js";
+import "./chunk-CEMNIGQH.js";
+import "./chunk-KGZBYWZ3.js";
+import "./chunk-Z2LGMV6C.js";
 export {
   ABLETIME_REST_PREFIX,
   ableTimeDocFromText,

package/dist/{abletime-rest-JZIIT5W3.js → abletime-rest-UEHOBLXD.js}

@@ -5,15 +5,16 @@ import {
   callAbleTimeRestTool,
   looksLikeAbleTimeUlid,
   textFromAbleTimeDoc
-} from "./chunk-66LAOKLK.js";
-import "./chunk-IFHHPPSL.js";
+} from "./chunk-D554YCHG.js";
+import "./chunk-J6ONZP74.js";
 import "./chunk-N7WZ6NIN.js";
-import "./chunk-KJM3E3NF.js";
+import "./chunk-6PFZ6XO7.js";
+import "./chunk-4TR3HZFT.js";
 import "./chunk-WDRMZKVB.js";
+import "./chunk-3HO2OY5T.js";
 import "./chunk-JT7R45JB.js";
 import "./chunk-77WWLBCI.js";
 import "./chunk-EHT2DRT4.js";
-import "./chunk-4TR3HZFT.js";
 export {
   ABLETIME_REST_PREFIX,
   ableTimeDocFromText,

package/dist/agents/cursor-runner.cjs

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/agents/cursor-runner.ts
-var import_node_fs14 = require("fs");
+var import_node_fs16 = require("fs");
 var import_node_readline2 = require("readline");
 
 // src/hook/nested-electron-env.ts
@@ -402,6 +402,79 @@ function extractJsonErrorMessage(obj) {
   }
   return null;
 }
+function looksLikeMinifiedJsDump(line) {
+  if (line.length < 200) return false;
+  return /yield Promise\.all/.test(line) || /\(0,[A-Za-z$]\.\w+\)/.test(line) || /CURSOR_RIPGREP_PATH/.test(line) || /findFilesWithRipgrep/.test(line) || /@cursor\/sdk\/dist\//.test(line) || looksLikeCursorSdkSourceDump(line);
+}
+function looksLikeCursorSdkSourceDump(text) {
+  const t = text.trim();
+  if (t.length < 120) return false;
+  return /cursor-runtime\/node_modules\/@cursor\/sdk/.test(t) || /importas [a-z] from"@bufbuild\/protobuf"/.test(t) || /file:\/\/[^\s]*@cursor\/sdk\/dist\/esm\/index\.js/.test(t);
+}
+function looksLikeHugeToolResultDump(text) {
+  if (looksLikeCursorSdkSourceDump(text)) return true;
+  const t = text.trim();
+  if (t.length < 4e3) return false;
+  return looksLikeMinifiedJsDump(t);
+}
+function looksLikeJobWaitResult(rec) {
+  if (typeof rec.delta === "string") {
+    return typeof rec.status === "string" || typeof rec.id === "string" || typeof rec.stillRunning === "boolean";
+  }
+  if (typeof rec.stopped === "boolean") {
+    return typeof rec.id === "string" || typeof rec.status === "string";
+  }
+  return rec.started === true || rec.reason === "already-running";
+}
+function clipJobWaitResultJson(content) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("{")) return void 0;
+  try {
+    const rec = JSON.parse(trimmed);
+    if (!looksLikeJobWaitResult(rec)) return void 0;
+    if (typeof rec.delta === "string" && rec.delta.length > 3500) {
+      rec.delta = `\u2026(truncated ${rec.delta.length} chars)
+${rec.delta.slice(-3500)}`;
+    }
+    if (typeof rec.progress === "string" && rec.progress.length > 800) {
+      rec.progress = rec.progress.slice(-800);
+    }
+    if (typeof rec.hint === "string" && rec.hint.length > 240) {
+      rec.hint = rec.hint.slice(0, 240);
+    }
+    let out = JSON.stringify(rec);
+    if (out.length <= TOOL_RESULT_STORE_MAX_CHARS) return out;
+    return JSON.stringify({
+      stillRunning: rec.stillRunning,
+      ok: rec.ok,
+      failed: rec.failed,
+      status: rec.status,
+      id: rec.id,
+      phase: rec.phase,
+      delta: typeof rec.delta === "string" ? rec.delta.slice(-2500) : ""
+    });
+  } catch {
+    return void 0;
+  }
+}
+function clipToolResultForStore(content) {
+  if (content == null) return void 0;
+  if (looksLikeCursorSdkSourceDump(content) || looksLikeMinifiedJsDump(content)) {
+    return `${HUGE_TOOL_RESULT_SUMMARY} (${content.length} chars omitted)`;
+  }
+  const jobClipped = clipJobWaitResultJson(content);
+  if (jobClipped) return jobClipped;
+  if (content.length <= TOOL_RESULT_STORE_MAX_CHARS) return content;
+  const head = 5e3;
+  const tail = 2e3;
+  return `${content.slice(0, head)}
+
+\u2026(truncated ${content.length} chars \u2014 write output to .context/cli/ and read a slice)
+
+${content.slice(-tail)}`;
+}
+var HUGE_TOOL_RESULT_SUMMARY = "Agent crashed mid-turn after a huge tool result. Write CLI/HTTP output to .context/cli/ and read a slice \u2014 never dump raw --json/--expand into the tool result.";
+var TOOL_RESULT_STORE_MAX_CHARS = 8e3;
 function looksLikeCursorHttp2StreamClose(text) {
   return /nghttp2/i.test(text.trim());
 }
@@ -458,7 +531,7 @@ async function retryOnceOnRetryableCursorError(fn, onRetry, delayMs = CURSOR_RET
     if (!isRetryableCursorTransportError(err)) throw err;
     onRetry?.(err);
     if (delayMs > 0) {
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
     }
     return fn();
   }
@@ -486,8 +559,8 @@ async function* iterateUntilIdle(iterable, idleMs, onIdle, activity) {
       let idleTimer;
       const raced = await Promise.race([
         pending.then((result) => ({ kind: "item", result })),
-        new Promise((resolve) => {
-          idleTimer = setTimeout(() => resolve({ kind: "idle" }), waitMs);
+        new Promise((resolve2) => {
+          idleTimer = setTimeout(() => resolve2({ kind: "idle" }), waitMs);
           idleTimer.unref?.();
         })
       ]);
@@ -511,6 +584,189 @@ async function* iterateUntilIdle(iterable, idleMs, onIdle, activity) {
   }
 }
 
+// src/agents/sliced-file-read.ts
+var import_node_fs14 = require("fs");
+var import_node_path16 = require("path");
+var SLICED_READ_DEFAULT_LIMIT = 200;
+var SLICED_READ_MAX_LINE_CHARS = 2e3;
+var SLICED_READ_DESCRIPTION = "Read a text file. Defaults to 200 lines (and a small char budget). Pass offset (1-based) + limit to continue \u2014 never request the whole file when it is large.";
+var SLICED_READ_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    path: {
+      type: "string",
+      description: "Absolute or cwd-relative path inside the worktree."
+    },
+    offset: {
+      type: "number",
+      description: "1-based start line (default 1)."
+    },
+    limit: {
+      type: "number",
+      description: `Max lines to return (default ${SLICED_READ_DEFAULT_LIMIT}).`
+    }
+  },
+  required: ["path"]
+};
+function realpathOrSelf(path) {
+  try {
+    return (0, import_node_fs14.realpathSync)(path);
+  } catch {
+    return (0, import_node_path16.resolve)(path);
+  }
+}
+function isOutsideWorktree(root, abs) {
+  const rel = (0, import_node_path16.relative)(root, abs);
+  return rel === ".." || rel.startsWith(`..${import_node_path16.sep}`) || (0, import_node_path16.isAbsolute)(rel);
+}
+function resolveWithinCwd(cwd, input) {
+  const root = realpathOrSelf(cwd);
+  const abs = (0, import_node_path16.isAbsolute)(input) ? (0, import_node_path16.resolve)(input) : (0, import_node_path16.resolve)(root, input);
+  if (isOutsideWorktree(root, abs)) {
+    throw new Error(`Path is outside the worktree: ${input}`);
+  }
+  const real = realpathOrSelf(abs);
+  if (isOutsideWorktree(root, real)) {
+    throw new Error(`Path is outside the worktree: ${input}`);
+  }
+  return real;
+}
+function capLine(line) {
+  if (line.length <= SLICED_READ_MAX_LINE_CHARS) return line;
+  return `${line.slice(0, SLICED_READ_MAX_LINE_CHARS)}\u2026(${line.length - SLICED_READ_MAX_LINE_CHARS} more chars on this line)`;
+}
+function looksBinary(buf) {
+  const n = Math.min(buf.length, 8192);
+  for (let i = 0; i < n; i += 1) {
+    if (buf[i] === 0) return true;
+  }
+  return false;
+}
+function asPositiveInt(value, fallback) {
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.max(1, Math.floor(n));
+}
+function executeSlicedFileRead(cwd, args) {
+  const rawPath = typeof args.path === "string" ? args.path.trim() : "";
+  if (!rawPath) return "Error: path is required.";
+  let abs;
+  try {
+    abs = resolveWithinCwd(cwd, rawPath);
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  let buf;
+  try {
+    const st = (0, import_node_fs14.statSync)(abs);
+    if (!st.isFile()) return `Error: not a file: ${rawPath}`;
+    buf = (0, import_node_fs14.readFileSync)(abs);
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  if (looksBinary(buf)) {
+    return `Error: ${rawPath} looks binary (${buf.length} bytes). Do not dump it into the turn.`;
+  }
+  const text = buf.toString("utf8");
+  const lines = text.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  const totalLines = lines.length;
+  const offset = asPositiveInt(args.offset, 1);
+  const limit = asPositiveInt(args.limit, SLICED_READ_DEFAULT_LIMIT);
+  const start = Math.min(offset, totalLines + 1);
+  const end = Math.min(start + limit - 1, totalLines);
+  const numbered = [];
+  let used = 0;
+  let stoppedEarly = false;
+  for (let i = start; i <= end; i += 1) {
+    const row = `${String(i).padStart(6, " ")}|${capLine(lines[i - 1] ?? "")}`;
+    if (used + row.length + 1 > TOOL_RESULT_STORE_MAX_CHARS && numbered.length > 0) {
+      stoppedEarly = true;
+      break;
+    }
+    numbered.push(row);
+    used += row.length + 1;
+  }
+  const header = `${rawPath} (${totalLines} lines, ${buf.length} bytes)`;
+  if (totalLines === 0) return `${header}
+(empty file)`;
+  if (start > totalLines) {
+    return `${header}
+offset ${offset} is past EOF. Last line is ${totalLines}.`;
+  }
+  const shownEnd = start + numbered.length - 1;
+  const truncated = stoppedEarly || shownEnd < totalLines;
+  const body = numbered.join("\n");
+  if (!truncated && start === 1) return `${header}
+${body}`;
+  const next = shownEnd + 1;
+  const hint = truncated ? `
+
+\u2026truncated; ${totalLines - shownEnd} lines remain. Re-call with offset=${next} (and limit) \u2014 do not read the whole file.` : start > 1 ? `
+
+(lines ${start}\u2013${shownEnd} of ${totalLines})` : "";
+  return `${header}
+${body}${hint}`;
+}
+function slicedReadCustomToolConfig(cwd) {
+  return {
+    description: SLICED_READ_DESCRIPTION,
+    inputSchema: SLICED_READ_INPUT_SCHEMA,
+    execute: (args) => executeSlicedFileRead(cwd, args)
+  };
+}
+
+// src/agents/tool-result-clip.ts
+var import_node_fs15 = require("fs");
+var import_node_path17 = require("path");
+
+// src/paths/workspace-scratch.ts
+var CLI_DIR = ".context/cli";
+
+// src/agents/tool-result-clip.ts
+function spillPath(cwd, prefix) {
+  const stamp = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const safe = prefix.replace(/[^a-zA-Z0-9_-]+/g, "-").slice(0, 40) || "tool";
+  return (0, import_node_path17.join)(cwd, CLI_DIR, `${safe}-${stamp}.txt`);
+}
+function spillToolResultToCli(content, opts) {
+  const cwd = opts?.cwd?.trim();
+  if (!cwd || !content) return null;
+  const file = spillPath(cwd, opts?.prefix ?? "tool-result");
+  try {
+    (0, import_node_fs15.mkdirSync)((0, import_node_path17.join)(cwd, CLI_DIR), { recursive: true });
+    (0, import_node_fs15.writeFileSync)(file, content, "utf8");
+    return file;
+  } catch {
+    return null;
+  }
+}
+function spillAndClipToolResult(content, opts) {
+  const clipped = clipToolResultForStore(content);
+  if (clipped == null) return content;
+  if (clipped === content) return content;
+  if (looksLikeHugeToolResultDump(content)) return clipped;
+  const spilled = spillToolResultToCli(content, opts);
+  if (!spilled) return clipped;
+  return `${clipped}
+
+Full output: ${spilled} (${content.length} chars). Read that file with offset/limit \u2014 do not dump it whole.`;
+}
+function clipAgentEventForEmit(event, cwd) {
+  if (!event || typeof event !== "object") return event;
+  const rec = event;
+  if (rec.type === "tool_result" && typeof rec.content === "string") {
+    return {
+      ...rec,
+      content: spillAndClipToolResult(rec.content, { cwd, prefix: "cursor-tool" })
+    };
+  }
+  if ((rec.type === "stderr" || rec.type === "stdout") && typeof rec.data === "string" && looksLikeHugeToolResultDump(rec.data)) {
+    return { ...rec, data: clipToolResultForStore(rec.data) };
+  }
+  return event;
+}
+
 // src/agents/cursor-events.ts
 function usageFromCursor(usage) {
   if (!usage) return null;
@@ -569,8 +825,8 @@ function cursorGetUsageRunId(runId) {
 }
 var CURSOR_COST_POLL_MS = [0, 400, 800, 1600, 3200];
 function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
   });
 }
 async function fetchCursorTurnCostUsd(getUsage, usageBefore, opts) {
@@ -878,12 +1134,12 @@ function createAgentStreamCoalescer(emit2, opts) {
 // src/agents/cursor-runner.ts
 dropNestedElectronEnvFromProcess();
 function emit(event) {
-  process.stdout.write(`${JSON.stringify(event)}
+  process.stdout.write(`${JSON.stringify(clipAgentEventForEmit(event, process.cwd()))}
 `);
 }
 function localAgentStore(Store, threadId) {
   const root = cursorSdkStoreDir(threadId);
-  (0, import_node_fs14.mkdirSync)(root, { recursive: true });
+  (0, import_node_fs16.mkdirSync)(root, { recursive: true });
   return new Store(root);
 }
 async function cancelStaleLocalRuns(Agent, agentId, opts) {
@@ -954,9 +1210,13 @@ async function main() {
   const mode = req.planMode ? "plan" : "agent";
   const store = localAgentStore(JsonlLocalAgentStore, req.threadId);
   const isolateSources = [];
+  const customTools = {
+    read: slicedReadCustomToolConfig(req.cwd)
+  };
   const local = withCursorLocalHangGuards({
     cwd: req.cwd,
     store,
+    customTools,
     ...req.isolateAmbientMcp ? { settingSources: isolateSources } : {}
   });
   const mcpServers = req.mcpServers && Object.keys(req.mcpServers).length > 0 ? req.mcpServers : void 0;
@@ -966,6 +1226,7 @@ async function main() {
     mode,
     local,
     name: "Sideboard",
+    disallowedTools: ["read"],
     ...mcpServers ? { mcpServers } : {}
   };
   const retryTransport = (fn) => retryOnceOnRetryableCursorError(fn, (err) => {
@@ -982,6 +1243,7 @@ async function main() {
           model,
           mode,
           local,
+          disallowedTools: ["read"],
           ...mcpServers ? { mcpServers } : {}
         })
       ) : await createAgent();
@@ -1030,8 +1292,8 @@ async function main() {
     shuttingDown = true;
     void Promise.race([
       cancelLiveRun(),
-      new Promise((resolve) => {
-        setTimeout(resolve, 2e3);
+      new Promise((resolve2) => {
+        setTimeout(resolve2, 2e3);
       })
     ]).finally(() => process.exit(1));
   };
@@ -1086,8 +1348,8 @@ async function main() {
       stream.flush();
       const result = streamIdle ? await Promise.race([
         run2.wait(),
-        new Promise((resolve) => {
-          setTimeout(() => resolve({ status: "cancelled" }), 5e3);
+        new Promise((resolve2) => {
+          setTimeout(() => resolve2({ status: "cancelled" }), 5e3);
         })
       ]) : await run2.wait();
       if (result.status === "error") {