scalix 1.5.0 → 1.5.2

package/dist/api-client.js

@@ -28,7 +28,15 @@ export function parseRetryAfter(value) {
         return Math.max(0, date - Date.now());
     return undefined;
 }
-const DEFAULT_TIMEOUT_MS = 120_000;
+// Per-request abort. 300s matches the platform's own proxy walls; the old
+// 120s default aborted the client before a slow first token could arrive on
+// CPU-served models (the request was fine, we hung up on it). For reference,
+// the OpenAI and Anthropic SDKs both default to 600s.
+const DEFAULT_TIMEOUT_MS = (() => {
+    const v = process.env.SCALIX_REQUEST_TIMEOUT_MS;
+    const n = v ? parseInt(v, 10) : NaN;
+    return Number.isFinite(n) ? n : 0;
+})();
 // The capability probe only decides whether a turn streams. It must never be
 // the reason a turn is slow to start, so it gives up quickly and falls back to
 // the conservative answer.
@@ -116,8 +124,8 @@ export class ScalixClient {
         for (;;) {
             const prepared = this.prepareRequest(req);
             const body = JSON.stringify(prepared);
-            const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
-            const combined = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+            const timeoutSignal = this.timeoutMs > 0 ? AbortSignal.timeout(this.timeoutMs) : undefined;
+            const combined = signal && timeoutSignal ? AbortSignal.any([signal, timeoutSignal]) : (signal || timeoutSignal);
             const response = await fetch(url, {
                 method: 'POST',
                 headers: {
@@ -127,7 +135,7 @@ export class ScalixClient {
                     'x-client-type': 'cli',
                 },
                 body,
-                signal: combined,
+                signal: combined || undefined,
             });
             if (!response.ok) {
                 const text = await response.text().catch(() => '');

package/dist/board-context.js

@@ -0,0 +1,81 @@
+/**
+ * Crew board context (scalix-org roadmap/SCALIX-CREW.md, T2.2/T2.3).
+ *
+ * BOARD.md is a READ-ONLY projection of a crew's notice board, written into
+ * the workspace by whoever runs the session (the orchestrator's CrewHydrator
+ * for cloud sessions; the cockpit for local ones) and refreshed before each
+ * turn. The engine never writes it — posting goes through the
+ * scalix_crew_board_post platform tool, the board's only write path.
+ *
+ * Durable lessons do not live here either: a member that learns something
+ * permanent from a board note promotes it into project memory (/remember),
+ * deliberately. Board = news; memory = knowledge.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export const BOARD_FILE = 'BOARD.md';
+/** A board is news, not a document dump — cap what lands in context so a
+ *  runaway board cannot crowd the task out of the window. */
+export const BOARD_CONTEXT_MAX_CHARS = 16 * 1024;
+/** Read the workspace board projection. Null when absent or empty — those
+ *  mean "this session has no crew board", which is different from a board
+ *  with no notes (that renders its own explicit empty state). */
+export async function readBoardFile(cwd) {
+    try {
+        const raw = await fs.readFile(path.join(cwd, BOARD_FILE), 'utf-8');
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return null;
+        return trimmed.length > BOARD_CONTEXT_MAX_CHARS
+            ? trimmed.slice(0, BOARD_CONTEXT_MAX_CHARS) + '\n…(board truncated for context)'
+            : trimmed;
+    }
+    catch {
+        return null;
+    }
+}
+export function boardToContext(board) {
+    if (!board)
+        return '';
+    return [
+        '## Crew Board (read-only projection)',
+        'Shared coordination state from your crew, current as of session start.',
+        'Post updates with the scalix_crew_board_post tool. Never edit BOARD.md —',
+        'it is overwritten on every refresh and your edit would be silently lost.',
+        '',
+        board,
+    ].join('\n');
+}
+/**
+ * Turn-start freshness for a session whose system prompt is assembled once:
+ * tracks the last projection seen and, when the file moves, hands back a
+ * system note carrying the new copy for the conversation history. One file
+ * read per turn; a quiet board costs nothing else.
+ */
+export class BoardTurnRefresher {
+    cwd;
+    lastSeen = null;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    /** Baseline — call once near session start, after the system prompt has
+     *  embedded the board, so the first turnNote() only fires on real change. */
+    async prime() {
+        this.lastSeen = await readBoardFile(this.cwd);
+    }
+    /** Null when nothing changed (or the file vanished — a removed projection
+     *  is a session-plumbing event, not news to tell the model about). */
+    async turnNote() {
+        const current = await readBoardFile(this.cwd);
+        if (current === this.lastSeen)
+            return null;
+        this.lastSeen = current;
+        if (current === null)
+            return null;
+        return [
+            '## Crew Board (updated since your last turn — supersedes earlier copies)',
+            '',
+            current,
+        ].join('\n');
+    }
+}