@turmind/halo 1.1.2 → 1.1.4

package/dist/index.js

@@ -2339,6 +2339,13 @@ function ensureHaloHome(haloHome2) {
     fs7.rmSync(staleWsSkill, { recursive: true, force: true });
     console.log("[Init] Removed stale `ws` skill (renamed to `workspace`)");
   }
+  for (const staleId of ["nova-web-search", "openai-web-search"]) {
+    const staleDir = path8.join(globalDir2, "skills", staleId);
+    if (fs7.existsSync(staleDir)) {
+      fs7.rmSync(staleDir, { recursive: true, force: true });
+      console.log(`[Init] Removed stale \`${staleId}\` skill (merged into \`web-search\`)`);
+    }
+  }
   const docsSrc = resolveDocsSource();
   if (!docsSrc) {
     console.log(`[Init] No docs source found \u2014 skipping platform docs seed. Searched: ${DOCS_SRC_CANDIDATES.join(", ")}`);
@@ -2400,7 +2407,7 @@ var init_init = __esm({
       path8.resolve(__dirname, "..", "bundled-docs"),
       path8.resolve(__dirname, "..", "..", "..", ".halo", "docs")
     ];
-    TEMPLATE_VERSION = 49;
+    TEMPLATE_VERSION = 52;
     VERSION_FILE = ".template-version";
     SKIP_NAMES = /* @__PURE__ */ new Set([".DS_Store", "schema.sql", "__pycache__", ".pytest_cache"]);
     BUILTIN_AGENT_IDS = /* @__PURE__ */ new Set([
@@ -2434,7 +2441,7 @@ var init_init = __esm({
       // Capability skills, model-invoked only (user-invocable: false — no slash
       // command). Preinstalled because they're broadly useful out of the box.
       "aws-knowledge",
-      "nova-web-search",
+      "web-search",
       // The agent's visual "face": teaches it that `.halo/canvas/self.html`
       // (seeded per-workspace, see ensureWorkspaceHalo) is a live self-portrait
       // it can drive in real time by emitting `<<<SHOW: …js… >>>`, which the admin
@@ -3324,7 +3331,12 @@ async function deliverGoalRound(host, worker) {
   const activeChildren = db.select({ id: agentSessions.id }).from(agentSessions).where(and2(eq2(agentSessions.parentId, worker.id), isNull(agentSessions.stoppedAt), isNull(agentSessions.archivedAt))).all();
   if (activeChildren.length > 0 || worker.messageQueue.length > 0)
     return;
-  const report = worker.finalOutput || worker.output || "(no output)";
+  let report = worker.finalOutput || worker.output || "(no output)";
+  if (worker.turnError) {
+    report = `[WORKER ABORTED: this round was terminated by an unrecoverable error, NOT a normal wrap-up. Error: ${worker.turnError}. The text below is a partial trace of the aborted turn \u2014 judge this as an interrupted round, do not score it as a completed result. Re-dispatch with query_session to let the worker resume.]
+
+${report}`;
+  }
   const caps = state.caps;
   const currentSpecHash = hashFileOrNull(goalSpecPath(host.workspaceRoot, state.goalId));
   if (!currentSpecHash || currentSpecHash !== state.specHash) {
@@ -5127,6 +5139,17 @@ var init_session_ui_store = __esm({
       /** Last activity (event reduced / view built) per uiStates key — the idle
        *  sweep's eviction clock. Invariant: every uiStates key has an entry. */
       uiStateTouched = /* @__PURE__ */ new Map();
+      /** Roots whose in-memory UIState holds local mutations (event reduced in,
+       *  notification appended, log replaced) **not yet persisted** — marked on
+       *  every mutation, cleared once persistUIState lands the snapshot. A state
+       *  not in this set adds nothing to what's on disk: either it's a pure disk
+       *  seed (built to *view* a session another process may be driving — a cron
+       *  `halo cli` child shares the workspace's session files and keeps appending
+       *  after the seed), or its mutations were already flushed. The WS
+       *  detach/switch saves gate on `isUIStateDirty`: writing a clean state back
+       *  would overwrite the other process's newer messages with this process's
+       *  frozen snapshot (the cron-session UI-log truncation incident). */
+      uiStateDirty = /* @__PURE__ */ new Set();
       constructor(host) {
         this.host = host;
         this.db = host.getDb();
@@ -5223,6 +5246,7 @@ var init_session_ui_store = __esm({
       reduceIntoUIState(rootId, event) {
         try {
           const state = this.ensureUIState(rootId);
+          this.uiStateDirty.add(rootId);
           const result = applyEvent(state, event);
           if (result.subSessionSave) {
             this.persistSubSession(state, rootId, result.subSessionSave);
@@ -5319,6 +5343,7 @@ var init_session_ui_store = __esm({
             archiveCount: archive?.count,
             archivedUserDelta: archive?.userDelta
           });
+          this.uiStateDirty.delete(rootId);
         } catch (err) {
           console.error(`[SessionUIStore] persistUIState failed for ${rootId}: ${err instanceof Error ? err.message : String(err)}`);
         }
@@ -5438,6 +5463,14 @@ var init_session_ui_store = __esm({
       getCachedUIState(rootSessionId) {
         return this.uiStates.get(rootSessionId) ?? null;
       }
+      /** Whether the cached UIState holds local mutations not yet persisted.
+       *  False for a state that was only seeded from disk (view of a session
+       *  another process drives) or whose mutations already flushed — writing
+       *  such a state back is at best a no-op and at worst overwrites a fresher
+       *  file (see uiStateDirty). */
+      isUIStateDirty(rootSessionId) {
+        return this.uiStateDirty.has(rootSessionId);
+      }
       /**
        * Get the UIState for a session, restoring it from disk if it isn't
        * in memory yet. Returns null only when the session id doesn't exist
@@ -5470,6 +5503,7 @@ var init_session_ui_store = __esm({
           timestamp: Date.now(),
           agentName
         });
+        this.uiStateDirty.add(rootId);
         this.persistUIState(rootId, state);
       }
       /**
@@ -5483,6 +5517,7 @@ var init_session_ui_store = __esm({
         state.streamBuffer = "";
         state.turnToolCalls = [];
         state.turnContentBlocks = [];
+        this.uiStateDirty.add(rootId);
         this.persistUIState(rootId, state);
       }
       /**
@@ -5504,6 +5539,7 @@ var init_session_ui_store = __esm({
         this.uiStates.delete(sessionId);
         this.uiStateProjectPaths.delete(sessionId);
         this.uiStateTouched.delete(sessionId);
+        this.uiStateDirty.delete(sessionId);
       }
       /**
        * Evict UIStates whose tree has been idle past the TTL. This is THE eviction
@@ -5560,8 +5596,10 @@ var init_session_ui_store = __esm({
        * session evolving elsewhere would freeze on the first snapshot.
        */
       prepareForView(sessionId, selfDriven) {
-        if (!selfDriven)
+        if (!selfDriven) {
           this.uiStates.delete(sessionId);
+          this.uiStateDirty.delete(sessionId);
+        }
         this.uiStateProjectPaths.set(sessionId, this.host.workspaceRoot);
         return this.ensureUIState(sessionId);
       }
@@ -5571,6 +5609,7 @@ var init_session_ui_store = __esm({
         this.uiStates.delete(id);
         this.uiStateProjectPaths.delete(id);
         this.uiStateTouched.delete(id);
+        this.uiStateDirty.delete(id);
         const timer = this.persistTimers.get(id);
         if (timer) {
           clearTimeout(timer);
@@ -10392,6 +10431,7 @@ var init_session_manager = __esm({
           draftReset,
           output: "",
           finalOutput: "",
+          turnError: null,
           promise: null,
           abortController: null,
           messageQueue: [],
@@ -10695,6 +10735,13 @@ var init_session_manager = __esm({
       getCachedUIState(rootSessionId) {
         return this.uiStore.getCachedUIState(rootSessionId);
       }
+      /** Whether a root's cached UIState holds local mutations not yet persisted.
+       *  The WS save paths gate on this — a clean state (pure disk seed, or
+       *  already flushed) must not be written back over a file that another
+       *  process (cron `halo cli` child) may have advanced since. */
+      isUIStateDirty(rootSessionId) {
+        return this.uiStore.isUIStateDirty(rootSessionId);
+      }
       getUIState(rootSessionId) {
         return this.uiStore.getUIState(rootSessionId);
       }
@@ -10802,6 +10849,7 @@ var init_session_manager = __esm({
         const maxRetries = config.agent.maxRetries;
         session.output = "";
         session.finalOutput = "";
+        session.turnError = null;
         for (let attempt = 0; attempt < maxRetries; attempt++) {
           session.abortController = new AbortController();
           const signal = session.abortController.signal;
@@ -10858,6 +10906,7 @@ var init_session_manager = __esm({
             if (msg.includes("insufficient balance") || msg.includes("suspended") || msg.includes("invalid api key") || msg.includes("Invalid API Key") || msg.includes("Unauthorized") || msg.includes("authentication")) {
               console.error(`[SessionManager] Session ${session.id} account error: ${msg}`);
               this.emitEvent(session.id, { type: "error", error: msg, agentName: session.agentName, taskId: session.parentId ? session.id : void 0 });
+              session.turnError = msg;
               resultText = `Error: ${msg}`;
               break;
             }
@@ -10883,7 +10932,7 @@ var init_session_manager = __esm({
                 continue;
               }
             }
-            if (msg === "fetch failed" || msg === "Model request timed out" || msg.includes("UND_ERR_HEADERS_TIMEOUT") || msg.includes("HeadersTimeoutError") || msg.includes("socket hang up") || msg.includes("ECONNRESET") || msg.includes("ECONNREFUSED") || msg.includes("ETIMEDOUT") || msg.includes("EAI_AGAIN")) {
+            if (msg === "fetch failed" || msg === "Model request timed out" || msg.includes("http2 request did not get a response") || msg.includes("UND_ERR_HEADERS_TIMEOUT") || msg.includes("HeadersTimeoutError") || msg.includes("socket hang up") || msg.includes("ECONNRESET") || msg.includes("ECONNREFUSED") || msg.includes("ETIMEDOUT") || msg.includes("EAI_AGAIN")) {
               if (attempt + 1 < maxRetries) {
                 const delay = 1e3 * Math.pow(2, attempt) + Math.random() * 500;
                 console.debug(`[SessionManager] Session ${session.id} transient network error, retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${maxRetries}): ${msg}`);
@@ -10926,6 +10975,7 @@ var init_session_manager = __esm({
             const errDetail = [errName, httpStatus ? `HTTP ${httpStatus}` : ""].filter(Boolean).join(" ");
             console.error(`[SessionManager] Session ${session.id} error (attempt ${attempt + 1}/${maxRetries})${errDetail ? ` [${errDetail}]` : ""}: ${msg}`);
             this.emitEvent(session.id, { type: "error", error: msg, agentName: session.agentName, taskId: session.parentId ? session.id : void 0 });
+            session.turnError = errName ? `${errName}: ${msg}` : msg;
             resultText = `Error: ${errName ? `${errName}: ` : ""}${msg}`;
             break;
           }
@@ -10991,7 +11041,12 @@ var init_session_manager = __esm({
           return;
         }
         this.db.update(agentSessions).set({ stoppedAt: Date.now() }).where(eq6(agentSessions.id, session.id)).run();
-        const result = session.finalOutput || session.output || "(no output)";
+        let result = session.finalOutput || session.output || "(no output)";
+        if (session.turnError) {
+          result = `[SUB-AGENT ABORTED: the last turn was terminated by an unrecoverable error, NOT completed. Error: ${session.turnError}. The text below is a partial trace of the aborted turn \u2014 do not treat it as a finished result. Re-dispatch with query_session("${session.id}", ...) to let it resume.]
+
+${result}`;
+        }
         console.debug(`[SessionManager] Auto-report: ${session.id} \u2192 parent ${session.parentId} \u2014 result: ${result.slice(0, 150)}`);
         const reportCap = config.limits.autoReportMax;
         const truncatedReport = result.length > reportCap ? result.slice(0, reportCap) + `
@@ -20492,14 +20547,75 @@ var init_commands3 = __esm({
 import { Hono as Hono13 } from "hono";
 import path52 from "node:path";
 import fs44 from "node:fs";
+function sanitizeRuntimeId(runtimeSessionId) {
+  return runtimeSessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80);
+}
 function haloSessionId(runtimeSessionId) {
-  return `agentcore_${runtimeSessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80)}`;
+  return `agentcore_${sanitizeRuntimeId(runtimeSessionId)}`;
 }
 function userWorkspace(base, runtimeSessionId) {
-  const dir = path52.join(base, "users", runtimeSessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80));
+  const dir = path52.join(base, "users", sanitizeRuntimeId(runtimeSessionId));
   fs44.mkdirSync(dir, { recursive: true });
   return dir;
 }
+function acceptChunk(uploads, msg) {
+  const uploadId = msg.uploadId;
+  const seq = msg.seq;
+  const total = msg.total;
+  const mimeType = msg.mimeType;
+  const data = msg.data;
+  if (typeof uploadId !== "string" || !uploadId || uploadId.length > 64)
+    return "image_chunk: uploadId must be a non-empty string (\u226464 chars)";
+  if (typeof seq !== "number" || !Number.isInteger(seq) || seq < 0)
+    return "image_chunk: seq must be a non-negative integer";
+  if (typeof total !== "number" || !Number.isInteger(total) || total < 1 || total > MAX_CHUNKS_PER_UPLOAD)
+    return `image_chunk: total must be 1..${MAX_CHUNKS_PER_UPLOAD}`;
+  if (typeof mimeType !== "string" || typeof data !== "string" || !data)
+    return "image_chunk: string mimeType and non-empty string data required";
+  if (seq >= total)
+    return "image_chunk: seq out of range";
+  let up = uploads.get(uploadId);
+  if (!up) {
+    if (uploads.size >= MAX_PENDING_UPLOADS)
+      return `too many pending uploads (max ${MAX_PENDING_UPLOADS} per connection)`;
+    up = { chunks: new Array(total), received: 0, mimeType, size: 0 };
+    uploads.set(uploadId, up);
+  }
+  if (up.chunks.length !== total)
+    return "image_chunk: total mismatch across chunks of one uploadId";
+  if (up.chunks[seq] !== void 0)
+    return null;
+  if (up.size + data.length > MAX_IMAGE_BASE64_LENGTH) {
+    uploads.delete(uploadId);
+    return "image too large (max 8MB base64 per image)";
+  }
+  up.chunks[seq] = data;
+  up.received++;
+  up.size += data.length;
+  return null;
+}
+function claimImageRefs(uploads, raw) {
+  if (raw === void 0)
+    return [];
+  if (!Array.isArray(raw))
+    return { error: "imageRefs must be an array" };
+  if (raw.length > MAX_IMAGES_PER_MESSAGE)
+    return { error: `too many images (max ${MAX_IMAGES_PER_MESSAGE} per message)` };
+  const images = [];
+  for (const ref of raw) {
+    if (typeof ref !== "string")
+      return { error: "imageRefs entries must be strings" };
+    const up = uploads.get(ref);
+    if (!up)
+      return { error: `unknown uploadId: ${ref}` };
+    if (up.received !== up.chunks.length)
+      return { error: `upload ${ref} incomplete (${up.received}/${up.chunks.length} chunks)` };
+    images.push({ data: up.chunks.join(""), mimeType: up.mimeType });
+  }
+  for (const ref of raw)
+    uploads.delete(ref);
+  return images;
+}
 async function ensureSession(sm, workspace, sessionId) {
   if (sm.getSessionById(sessionId))
     return;
@@ -20638,6 +20754,7 @@ function setupAgentCoreWebSocket(deps) {
       ready ??= ensureSession(sm, userWs, sessionId).then(() => attachListener());
       return ready;
     };
+    const uploads = /* @__PURE__ */ new Map();
     ws.on("message", (raw) => {
       let msg;
       try {
@@ -20663,8 +20780,20 @@ function setupAgentCoreWebSocket(deps) {
         });
         return;
       }
+      if (msg.type === "image_chunk") {
+        const err = acceptChunk(uploads, msg);
+        if (err)
+          send({ type: "error", error: err });
+        return;
+      }
       const text5 = typeof msg.inputText === "string" ? msg.inputText.trim() : "";
-      if (!text5) {
+      const claimed = claimImageRefs(uploads, msg.imageRefs);
+      if (!Array.isArray(claimed)) {
+        send({ type: "error", error: claimed.error });
+        return;
+      }
+      const images = claimed;
+      if (!text5 && images.length === 0) {
         return;
       }
       if (text5.startsWith("/")) {
@@ -20722,10 +20851,29 @@ function setupAgentCoreWebSocket(deps) {
       void (async () => {
         try {
           await ensureOnce();
-          sm.appendUserMessage(sessionId, text5);
+          const notes = [];
+          for (const img of images) {
+            try {
+              const savedPath = await saveInboundMedia({
+                workspacePath: userWs,
+                accountId: sanitizeRuntimeId(runtimeSessionId),
+                channel: "agentcore",
+                buffer: Buffer.from(img.data, "base64"),
+                kind: "image",
+                mimeType: img.mimeType
+              });
+              notes.push(`[\u56FE\u7247\u5DF2\u4FDD\u5B58: ${savedPath}]`);
+            } catch (err) {
+              console.log(`[AgentCore] image save failed: ${err instanceof Error ? err.message : String(err)}`);
+              notes.push("[\u56FE\u7247]");
+            }
+          }
+          const fullText = notes.length > 0 ? text5 ? `${text5}
+${notes.join("\n")}` : notes.join("\n") : text5;
+          sm.appendUserMessage(sessionId, fullText);
           const result = await sm.sendUserMessage(sessionId, `[channel: agentcore]
 
-${text5}`);
+${fullText}`, images.length > 0 ? images : void 0);
           if (result === "queued")
             send({ type: "queued" });
         } catch (err) {
@@ -20736,19 +20884,25 @@ ${text5}`);
     ws.on("close", () => {
       unsubscribe?.();
       unsubscribe = null;
+      uploads.clear();
       activeOverrides.delete(runtimeSessionId);
     });
     console.log(`[AgentCore] ws connected \u2014 session ${sessionId}`);
   });
 }
-var SESSION_HEADER, activeOverrides;
+var SESSION_HEADER, MAX_IMAGES_PER_MESSAGE, MAX_IMAGE_BASE64_LENGTH, MAX_PENDING_UPLOADS, MAX_CHUNKS_PER_UPLOAD, activeOverrides;
 var init_agentcore = __esm({
   "packages/server/dist/routes/agentcore.js"() {
     "use strict";
     init_commands2();
     init_ui_log_builder();
     init_session_types();
+    init_media_store();
     SESSION_HEADER = "x-amzn-bedrock-agentcore-runtime-session-id";
+    MAX_IMAGES_PER_MESSAGE = 4;
+    MAX_IMAGE_BASE64_LENGTH = 8 * 1024 * 1024;
+    MAX_PENDING_UPLOADS = 4;
+    MAX_CHUNKS_PER_UPLOAD = 256;
     activeOverrides = /* @__PURE__ */ new Map();
   }
 });
@@ -21453,6 +21607,8 @@ function setupWebSocketHandler(deps) {
     const state = getState(client);
     if (!state)
       return;
+    if (!client.sessionManager.isUIStateDirty(client.sessionId))
+      return;
     const projectPath = resolveProjectPath2(client.projectId);
     const snapshot = createSaveSnapshot(state);
     if (snapshot.length === 0)
@@ -22065,6 +22221,9 @@ function createCronDb(globalDir2) {
   if (!cols.some((c) => c.name === "run_at")) {
     sqlite.exec(`ALTER TABLE cron_jobs ADD COLUMN run_at INTEGER`);
   }
+  if (!cols.some((c) => c.name === "timeout_sec")) {
+    sqlite.exec(`ALTER TABLE cron_jobs ADD COLUMN timeout_sec INTEGER`);
+  }
   const runCols = sqlite.prepare(`PRAGMA table_info(cron_runs)`).all();
   if (!runCols.some((c) => c.name === "pid")) {
     sqlite.exec(`ALTER TABLE cron_runs ADD COLUMN pid INTEGER`);
@@ -22105,6 +22264,10 @@ var init_cron_db = __esm({
       runAt: integer4("run_at"),
       /** IANA timezone name; null = host timezone. */
       timezone: text4("timezone"),
+      /** Max seconds a single cron-fired cli may run before the runner kills
+       *  it. NULL = default 3600 (runner.ts CLI_TIMEOUT_SEC). Range 60–21600,
+       *  enforced at the write points (REST routes / skill helper). */
+      timeoutSec: integer4("timeout_sec"),
       /** JSON array of `{channelType, accountId}` records. Cron output (final
        *  assistant text) is dispatched to each one. Empty array = log only. */
       targets: text4("targets").notNull().default("[]"),
@@ -22154,6 +22317,7 @@ CREATE TABLE IF NOT EXISTS cron_jobs (
   schedule        TEXT NOT NULL,
   run_at          INTEGER,
   timezone        TEXT,
+  timeout_sec     INTEGER,
   targets         TEXT NOT NULL DEFAULT '[]',
   enabled         INTEGER NOT NULL DEFAULT 1,
   last_run_status TEXT,
@@ -22587,6 +22751,7 @@ async function runJob(jobId, triggerKind) {
     const sessionId = `cron-${job.id}`;
     const args = ["cli", "-a", job.agentId, "-s", sessionId, "-w", job.workspacePath];
     const [spawnBin, spawnArgs] = process.platform === "win32" && cli.endsWith(".cmd") ? ["cmd.exe", ["/c", cli, ...args]] : [cli, args];
+    const timeoutSec = job.timeoutSec ?? CLI_TIMEOUT_SEC;
     const teeStream = fs48.createWriteStream(logPath, { flags: "a" });
     teeStream.write(`=== ${(/* @__PURE__ */ new Date()).toISOString()} cron run ${runId} job=${jobId} trigger=${triggerKind} ===
 `);
@@ -22617,7 +22782,7 @@ async function runJob(jobId, triggerKind) {
       const killTimer = setTimeout(() => {
         timedOut = true;
         teeStream.write(`
-[runner] timeout ${CLI_TIMEOUT_SEC}s \u2014 SIGTERM, grace ${KILL_GRACE_SEC}s
+[runner] timeout ${timeoutSec}s \u2014 SIGTERM, grace ${KILL_GRACE_SEC}s
 `);
         try {
           child.kill("SIGTERM");
@@ -22629,7 +22794,7 @@ async function runJob(jobId, triggerKind) {
           if (child.pid)
             killTreeHard(child.pid);
         }, KILL_GRACE_SEC * 1e3);
-      }, CLI_TIMEOUT_SEC * 1e3);
+      }, timeoutSec * 1e3);
       child.stdout?.on("data", (chunk) => {
         stdout += chunk.toString("utf-8");
         teeStream.write(chunk);
@@ -22665,7 +22830,7 @@ async function runJob(jobId, triggerKind) {
     let failureReason = null;
     if (result.exitCode === 124) {
       status = "timeout";
-      failureReason = `cli exceeded ${CLI_TIMEOUT_SEC}s timeout`;
+      failureReason = `cli exceeded ${timeoutSec}s timeout`;
     } else if (result.exitCode !== 0) {
       status = "failed";
       failureReason = stderr.slice(-500).trim() || `cli exited ${result.exitCode}`;
@@ -22813,6 +22978,15 @@ function validateSchedule(expr) {
     return err instanceof Error ? err.message : String(err);
   }
 }
+function validateTimeoutSec(v) {
+  if (typeof v !== "number" || !Number.isInteger(v)) {
+    return "timeoutSec must be an integer (seconds)";
+  }
+  if (v < TIMEOUT_SEC_MIN || v > TIMEOUT_SEC_MAX) {
+    return `timeoutSec must be between ${TIMEOUT_SEC_MIN} and ${TIMEOUT_SEC_MAX}`;
+  }
+  return null;
+}
 function createCronRoutes() {
   const router = new Hono14();
   router.get("/cron/jobs", async (c) => {
@@ -22856,6 +23030,11 @@ function createCronRoutes() {
     if (hasRunAt && body.runAt <= Date.now()) {
       return c.json({ error: "runAt must be in the future" }, 400);
     }
+    if (body.timeoutSec !== void 0 && body.timeoutSec !== null) {
+      const err = validateTimeoutSec(body.timeoutSec);
+      if (err)
+        return c.json({ error: err }, 400);
+    }
     const id = newJobId();
     const now = Date.now();
     getCronDb().insert(cronJobs).values({
@@ -22867,6 +23046,7 @@ function createCronRoutes() {
       schedule: hasSchedule ? body.schedule : "",
       runAt: hasRunAt ? body.runAt : null,
       timezone: body.timezone ?? null,
+      timeoutSec: body.timeoutSec ?? null,
       targets: JSON.stringify(body.targets ?? []),
       enabled: body.enabled === false ? 0 : 1,
       lastRunStatus: null,
@@ -22903,6 +23083,11 @@ function createCronRoutes() {
       if (body.runAt <= Date.now())
         return c.json({ error: "runAt must be in the future" }, 400);
     }
+    if (body.timeoutSec !== void 0 && body.timeoutSec !== null) {
+      const err = validateTimeoutSec(body.timeoutSec);
+      if (err)
+        return c.json({ error: err }, 400);
+    }
     const hasSchedule = typeof body.schedule === "string" && body.schedule.trim().length > 0;
     const hasRunAt = typeof body.runAt === "number";
     if (hasSchedule && hasRunAt) {
@@ -22930,6 +23115,8 @@ function createCronRoutes() {
       patch.runAt = nextRunAt;
     if (body.timezone !== void 0)
       patch.timezone = body.timezone || null;
+    if (body.timeoutSec !== void 0)
+      patch.timeoutSec = body.timeoutSec;
     if (body.targets !== void 0)
       patch.targets = JSON.stringify(body.targets);
     if (body.enabled !== void 0)
@@ -23045,6 +23232,7 @@ function computeNextRun(j) {
     return null;
   }
 }
+var TIMEOUT_SEC_MIN, TIMEOUT_SEC_MAX;
 var init_cron = __esm({
   "packages/server/dist/routes/cron.js"() {
     "use strict";
@@ -23052,6 +23240,8 @@ var init_cron = __esm({
     init_runner();
     init_dispatcher();
     init_broadcast();
+    TIMEOUT_SEC_MIN = 60;
+    TIMEOUT_SEC_MAX = 21600;
   }
 });
 
@@ -28954,7 +29144,7 @@ var init_dist2 = __esm({
     init_git_ssh();
     __dirname3 = path64.dirname(fileURLToPath3(import.meta.url));
     PORT = config.server.port;
-    HALO_VERSION = "1.1.2";
+    HALO_VERSION = "1.1.4";
     PROJECT_ROOT = findProjectRoot();
     HALO_HOME4 = path64.join(homedir24(), ".halo");
     GIT_SHA = readGitSha();
@@ -29856,7 +30046,7 @@ import path65 from "node:path";
 import fs58 from "node:fs";
 import { homedir as homedir25 } from "node:os";
 import { parseArgs as parseArgs2 } from "node:util";
-var VERSION = "1.1.2";
+var VERSION = "1.1.4";
 var HELP_TOP = `Usage: halo <command> [options]
 
 Commands:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turmind/halo",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Halo — multi-agent collaborative workspace. CLI + TUI + HTTP/WS server in one package.",
   "type": "module",
   "license": "MIT",

package/templates/agents/default/agent.yaml

@@ -45,7 +45,7 @@ skills:
   - send-file
   - self
   - aws-knowledge
-  - nova-web-search
+  - web-search
   - cron
   - acp
   - halo

package/templates/models/aws-bedrock-claude-invoke.yaml

@@ -35,6 +35,34 @@ secrets:
 #   thinking.default           → effort selected when Thinking is on (adaptive)
 #   thinking.defaultBudgetTokens → budget selected when Thinking is on (manual)
 models:
+  - id: global.anthropic.claude-fable-5-1
+    displayName: Claude Fable 5.1
+    maxOutputTokens: 128000
+    contextWindow: 1000000
+    capabilities:
+      image: true
+      video: false
+      audio: false
+      promptCaching:
+        default: 1h
+        ttlPresets:
+          - { value: 5m, label: 5min }
+          - { value: 1h, label: 1hour }
+      thinking:
+        # Fable 5.1 — Mythos-class flagship refresh. Adaptive effort set
+        # confirmed by an invalid-value probe against Bedrock (2026-09-02):
+        # low / medium / high / xhigh / max, same as Fable 5. 1M context,
+        # 128K output. Smoke-tested on invoke (xhigh).
+        mode: adaptive
+        defaultEnabled: true
+        default: high       # flagship-of-flagships — high by default; xhigh/max on demand
+        effortPresets:
+          - { value: low, label: Low }
+          - { value: medium, label: Medium }
+          - { value: high, label: High }
+          - { value: xhigh, label: XHigh }
+          - { value: max, label: Max }
+
   - id: global.anthropic.claude-fable-5
     displayName: Claude Fable 5
     maxOutputTokens: 128000

package/templates/skills/cron/SKILL.md

@@ -53,6 +53,7 @@ Sensible defaults if user didn't say:
 | timezone   | leave unset (host time)                                       |
 | targets    | none (log only — the run shows in admin Cron tab)             |
 | label      | summarize from prompt + schedule                              |
+| timeout    | leave unset (3600s) — see `--timeout-sec` below               |
 
 ### 2. Translate the schedule
 
@@ -78,6 +79,13 @@ today" or "send the report next Monday morning".
 
 Ambiguous time ("morning")? Ask once for the exact hour.
 
+**Max run time (`--timeout-sec`, optional)** — each fire runs as a cli child
+that the server kills after `timeout_sec` seconds (integer, 60–21600). Unset
+= default 3600. Only set it when the user says so: a quick push job that
+should fail fast ("kill it after 5 minutes" → `--timeout-sec 300`), or a
+heavy analysis run that needs more than an hour (`--timeout-sec 7200`). On
+`update`, pass `--timeout-sec ""` to clear back to the default.
+
 ### 3. Channels (only when delivery is wanted)
 
 Run `channels` first to see what's available: