@inetafrica/open-claudia 3.4.22 → 3.4.24

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 3.4.24
+
+- A repeating watch keeps polling while its triggered delivery waits for a busy room, waits to retry after a failed or `/stop`-killed run, or runs. A new hit folds into that one pending delivery instead of queueing another, and the delivered prompt says how many more times the check passed and whether its latest run had cleared. On 24 Sep the event-bus watch went unpolled for 7.5 h behind a busy room, and after a killed delivery attempt its polling never resumed. One-shot watches are unchanged, and the 15-minute "⏳ Watch … waiting" line still goes out once per occurrence.
+- A watch whose check times out 3 times in a row now wakes the agent once, marked "Watch check timing out", and keeps polling; any completed check resets the count. A hanging health check used to be logged `idle (check timed out)` and never alarm. The alarm does not use up a one-shot watch.
+- Wakeups more than ~24.8 days out no longer fire at once. `setTimeout` overflows past 2^31-1 ms, which fired a 2028 reminder 61 s after it was set (17 Sep); far wakeups now sleep in chunks and re-plan until due, then fire once. `schedule-wakeup` refuses a `<when>` more than 10 years out, in the CLI and in the loopback route.
+- A queued delivery is no longer stranded when a jobs-store write throws (a full disk, a torn journal). Those paths returned without a retry timer, so the alarm was never tried again; they now keep the retry armed and say so in watch.log. This matches the watch alarms that triggered during long turns on 21 and 23 Sep and were never delivered. A regression test also pins that a delivery queued behind a long turn survives the turn's compaction and runs once at the next idle moment, on the compacted session; that path already worked.
+- `cron-list` and `watch-list` say where a fired job stands (delivery waiting, running, retrying or dead) instead of listing it as still to come. A triggered watch whose delivery was queued read "EXPIRED (fires on next poll)" (21 Sep), and a fired 2028 reminder still read "fires 2028-08-01" (17 Sep).
+- `open-claudia say` and the send-file/voice/photo routes now say which step failed when the channel adapter refuses the upload, instead of a bare `loopback 500: {"ok":false}` (10 Sep). The adapter's own error stays in bot.log.
+- Release gate: `test-provider-pack-review.js` gives each probe child 120 s instead of 30 s and reports a timeout as a timeout rather than "failed (null)" (v3.4.19, job 43703). The parity suite's cap for it rises to 8 minutes so it cannot undercut its children.
+
+## 3.4.23
+
+- Watch, wakeup and cron turns now stream their progress (interim narration, and thinking under `/verbose`) like chat turns. The live preview was gated to chat turns only, so a watch-woken turn showed the bell notice and "thinking…" and then nothing until its final answer, however long it worked.
+- `/stop` no longer cancels the messages you send after it. It released the room the moment it killed the run, before that run had unwound, so a message sent in those seconds started, met the stop flag at its pre-spawn checkpoint and was cancelled "before the provider started" — three messages lost after one `/stop` on 24 Sep. The room now stays busy until the stopped run's own unwind releases it and drains the queue (a 30 s backstop covers a child that never reports its exit), and the stop flag names the run it stops, so it can never cancel another.
+- "Queued." now says what the message is waiting on once the wait passes two minutes, e.g. `Queued behind the watch "Phone alarm" (running 42 min). /stop cancels it.`
+- A watch that has triggered but waited 15 minutes behind a busy room posts one plain line per occurrence, so an alarm is never hidden for hours (24 Sep: 2 h and 7.5 h, with nothing in the chat).
+
 ## 3.4.22
 
 Supersedes 3.4.21, which was tagged but never published: its build failed because `test-upgrade-path.js` was wired into the test chain without being committed. Nothing shipped from that tag.

package/bin/schedule.js

@@ -8,7 +8,8 @@ Background scheduling — manage wakeups and crons.
 
 Wakeups (one-shot, resumes the same conversation):
   open-claudia schedule-wakeup <when> "<prompt>" [--label "<label>"]
-    <when>: duration (e.g. 30s, 5m, 2h, 1d) OR an ISO datetime (e.g. 2026-05-16T15:00:00Z)
+    <when>: duration (e.g. 30s, 5m, 2h, 1d) OR an ISO datetime (e.g. 2026-05-16T15:00:00Z),
+            at most 10 years out
 
 Crons (recurring):
   open-claudia cron-add "<5-field cron>" "<prompt>" [--label "<label>"] [--project <name>]
@@ -25,6 +26,8 @@ Watches (silent background monitor — polls a shell check, wakes you only on a
                datetime. Default 2h. A watch that reaches its timeout without
                the check ever passing FIRES anyway on the next poll, with the
                prompt marked "Watch expired" — no watch can end silently.
+    A check that times out (30s) 3 times in a row wakes the agent once, marked
+    "Watch check timing out"; the watch keeps polling.
   open-claudia watch-list                        # watches on this channel + master switch state
   open-claudia watch-remove <id>                 # remove a watch by id
   open-claudia watch-on / watch-off              # global master switch for ALL watches (owner)
@@ -37,6 +40,10 @@ switching providers starts a fresh thread.
 `;
 
 const DUR = /^(\d+)\s*(s|sec|secs|m|min|mins|h|hr|hrs|d|day|days)$/i;
+// Mirrors core/scheduler MAX_WAKEUP_HORIZON_MS: a wakeup further out than this
+// is a typo or a mis-parsed <when> (one was set 1273 years out).
+const MAX_WAKEUP_YEARS = 10;
+const MAX_WAKEUP_HORIZON_MS = MAX_WAKEUP_YEARS * 365.25 * 24 * 60 * 60 * 1000;
 
 function parseWhen(s) {
   if (!s) return null;
@@ -63,13 +70,41 @@ function takeFlag(args, name) {
   return v;
 }
 
+// Where a job stands once it has fired. A fired job used to stay listed as a
+// future one ("fires 2028-08-01", "EXPIRED (fires on next poll)") while its
+// delivery was queued, running or dead (17 and 21 Sep).
+function jobProgress(j) {
+  const since = j.check && j.watchTriggeredOccurrenceId && j.watchTriggeredOccurrenceId === j.occurrenceId && Number(j.watchTriggeredAt) > 0
+    ? `TRIGGERED ${new Date(Number(j.watchTriggeredAt)).toISOString()}, ` : "";
+  const state = {
+    running: "delivery running",
+    deferred: "delivery waiting for a busy room",
+    failed: `delivery failed (${j.lastError?.code || "error"}), retrying`,
+    "dead-letter": `delivery failed (${j.lastError?.code || "error"}), DEAD: will not fire`,
+  }[j.status];
+  return state ? `${since}${state}` : "";
+}
+
 function fmtJob(j) {
   const when = j.kind === "wakeup"
     ? `fires ${new Date(j.fireAt).toISOString()}`
     : `schedule "${j.schedule}"`;
   const proj = j.project ? ` [${j.project}]` : "";
   const src = j.source ? ` (${j.source})` : "";
-  return `${j.id}  ${j.kind}  ${j.label || "(no label)"}${proj}${src}  ${when}`;
+  const progress = jobProgress(j);
+  return `${j.id}  ${j.kind}  ${j.label || "(no label)"}${proj}${src}  ${when}${progress ? `  [${progress}]` : ""}`;
+}
+
+function fmtWatch(w, now = Date.now()) {
+  const mode = w.repeat ? "repeating" : "one-shot";
+  const progress = jobProgress(w);
+  const expiry = progress ? `  ${progress}`
+    : Number(w.expiresAt) > 0
+      ? (now >= Number(w.expiresAt)
+        ? "  EXPIRED (fires on next poll)"
+        : `  expires ${new Date(Number(w.expiresAt)).toISOString()}`)
+      : "  no expiry (pre-timeout watch)";
+  return `${w.id}  ${mode}  polls "${w.schedule}"${expiry}  check: ${w.check}  → ${w.label || "(no label)"}`;
 }
 
 async function runScheduleWakeup(args) {
@@ -82,6 +117,11 @@ async function runScheduleWakeup(args) {
     console.error(`Could not parse <when>: "${rest[0]}". Use a duration (5m, 2h, 1d) or ISO datetime.`);
     process.exit(2);
   }
+  if (when - Date.now() > MAX_WAKEUP_HORIZON_MS) {
+    const at = new Date(when);
+    console.error(`<when> "${rest[0]}" is ${Number.isNaN(at.getTime()) ? "past any valid date" : at.toISOString()}, more than ${MAX_WAKEUP_YEARS} years out. Check the date; for a far reminder use a yearly cron-add.`);
+    process.exit(2);
+  }
   const prompt = rest.slice(1).join(" ");
   if (!prompt) { console.error("Missing prompt."); process.exit(2); }
   try {
@@ -178,15 +218,7 @@ async function runWatchList() {
     const list = res.watches || [];
     console.log(`Watches: master switch is ${res.enabled ? "ON" : "OFF"}.`);
     if (list.length === 0) { console.log("No watches on this channel."); process.exit(0); }
-    for (const w of list) {
-      const mode = w.repeat ? "repeating" : "one-shot";
-      const expiry = Number(w.expiresAt) > 0
-        ? (Date.now() >= Number(w.expiresAt)
-          ? "  EXPIRED (fires on next poll)"
-          : `  expires ${new Date(Number(w.expiresAt)).toISOString()}`)
-        : "  no expiry (pre-timeout watch)";
-      console.log(`${w.id}  ${mode}  polls "${w.schedule}"${expiry}  check: ${w.check}  → ${w.label || "(no label)"}`);
-    }
+    for (const w of list) console.log(fmtWatch(w));
     process.exit(0);
   } catch (e) { console.error(e.message); process.exit(1); }
 }
@@ -211,6 +243,8 @@ async function runWatchToggle(enabled) {
 
 module.exports = {
   HELP,
+  fmtJob,
+  fmtWatch,
   runScheduleWakeup,
   runCronAdd,
   runCronList,

package/core/handlers.js

@@ -20,7 +20,7 @@ const {
   getProviderSettings, resolveProviderSettings,
   getProjectSessions, getLastProjectSession, userOwnsProviderSession,
   createSessionCallbackToken, linkIdentity,
-  roomSettingsFor, setRoomSetting,
+  roomSettingsFor, setRoomSetting, cancelFlagFor,
 } = require("./state");
 const { canonicalForChannel, canonicalForTelegram, normalizeCanonicalUserId, channelKey, identities, isConfiguredOwnerChannel, removeIdentityMapping } = require("./identity");
 const { isChatAuthorized, isChatOwner, recordPendingAuthRequest, authRequestLabel, hasOwner, bootstrapOwner } = require("./access");
@@ -1642,6 +1642,17 @@ register({
   },
 });
 
+// How long /stop waits for a stopped child to report its exit before it
+// releases the room anyway (SIGKILL follows SIGTERM after 3 s).
+const STOP_RELEASE_MS = 30 * 1000;
+function releaseStuckStop(state, proc, stopped) {
+  if (state.runningProcess !== proc) return;
+  if (proc.exitCode != null || proc.signalCode != null) return; // exited: its unwind releases the room
+  console.warn(`[stop] child ${proc.pid} never reported its exit; releasing the room`);
+  state.runningProcess = null;
+  if (state.cancelRequested === stopped) state.cancelRequested = false;
+}
+
 register({
   name: "stop", description: "Cancel running task",
   handler: async (env) => {
@@ -1655,14 +1666,23 @@ register({
       return n ? ` ${n} queued message${n === 1 ? "" : "s"} will run next.` : "";
     };
     if (state.runningProcess) {
-      const pid = state.runningProcess.pid;
+      const proc = state.runningProcess;
+      const pid = proc.pid;
       const { killProcessTree } = require("./process-tree");
       // Quiet unwind: deliverForegroundResult consumes this flag to suppress
-      // the "run failed" diagnostic the SIGTERM exit would otherwise emit.
-      state.cancelRequested = true;
+      // the "run failed" diagnostic the SIGTERM exit would otherwise emit. It
+      // names the run it stops, so it can never cancel a different one.
+      const stopped = cancelFlagFor(state);
+      state.cancelRequested = stopped;
       killProcessTree(pid, "SIGTERM");
       setTimeout(() => killProcessTree(pid, "SIGKILL"), 3000);
-      state.runningProcess = null;
+      // The room stays busy until the stopped run has unwound: its own
+      // finally releases the lock, clears this flag and drains the queue.
+      // Releasing it here let a message sent in those seconds start, meet the
+      // flag and be cancelled "before the provider started" (24 Sep: three
+      // messages lost after one /stop). Backstop: a child that never reports
+      // its exit must not pin the room.
+      setTimeout(() => releaseStuckStop(state, proc, stopped), STOP_RELEASE_MS).unref?.();
       // Stop pending preview flushes but keep statusMessageId/Channel: the
       // killed run's delivery unwind edits the preview to drop its footer.
       if (state.streamInterval) { clearTimeout(state.streamInterval); state.streamInterval = null; }
@@ -1675,7 +1695,7 @@ register({
     } else if (state.preparingRun) {
       // Turn is mid-recall/prompt-build — no process to kill yet. Flag it so
       // the runner's pre-spawn shouldAbort checkpoint bails before spawning.
-      state.cancelRequested = true;
+      state.cancelRequested = cancelFlagFor(state);
       if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; state.thinkingPhase = false; state.typingTick = null; }
       try { currentAdapter()?.typingStop?.(currentChannelId()); } catch (_) {}
       await sideCancellation;

package/core/loopback.js

@@ -58,6 +58,14 @@ function reply(res, code, body) {
   res.end(data);
 }
 
+// An adapter's send* resolves false after logging its own error, so the JSON
+// used to say only {"ok":false} (10 Sep: every `say` failed like that through
+// a Kazee outage). Name the step that failed; the adapter's message may carry
+// request details, so it stays in bot.log.
+function undeliveredReason(adapter, what) {
+  return `${adapter.type || adapter.id} adapter did not deliver the ${what}: the channel rejected it or was unreachable (details in bot.log)`;
+}
+
 function authOk(req) {
   return (req.headers["authorization"] || "") === `Bearer ${token}`;
 }
@@ -154,7 +162,7 @@ async function handleSend(req, res, url, kind) {
   } finally {
     if (kind !== "send-voice") { try { fs.unlinkSync(tmp); } catch (e) {} }
   }
-  return reply(res, ok ? 200 : 500, { ok });
+  return ok ? reply(res, 200, { ok }) : reply(res, 500, { ok, error: undeliveredReason(adapter, kind === "send-voice" ? "voice note" : kind.slice(5)) });
 }
 
 async function handleJson(req, res, url, kind) {
@@ -215,7 +223,7 @@ async function handleJson(req, res, url, kind) {
       return reply(res, 500, { error: `voice send failed: ${e.message}` });
     }
     try { fs.unlinkSync(voicePath); } catch (e) {}
-    return reply(res, ok ? 200 : 500, { ok });
+    return ok ? reply(res, 200, { ok }) : reply(res, 500, { ok, error: undeliveredReason(adapter, "voice note") });
   }
 
   if (kind === "tts") {
@@ -271,6 +279,9 @@ async function handleJson(req, res, url, kind) {
   if (kind === "schedule-wakeup") {
     const fireAt = Number(payload.fireAt);
     if (!Number.isFinite(fireAt) || fireAt <= 0) return reply(res, 400, { error: "missing/invalid fireAt" });
+    if (fireAt - Date.now() > scheduler.MAX_WAKEUP_HORIZON_MS) {
+      return reply(res, 400, { error: "fireAt is more than 10 years out; check the date (a far reminder belongs in a yearly cron)" });
+    }
     if (!payload.prompt) return reply(res, 400, { error: "missing prompt" });
     const job = scheduler.addJob({
       kind: "wakeup",

package/core/runner.js

@@ -13,7 +13,7 @@ const {
 } = require("./config");
 const {
   currentState, saveState, recordSession,
-  resetSessionUsage, acquireRunLock, getActiveProvider, getProjectKey,
+  resetSessionUsage, acquireRunLock, cancelTargets, getActiveProvider, getProjectKey,
   getProviderSession, setProviderSession, clearProviderSession, quarantineProviderSession, getUsageForSession, commitProviderCompaction,
   resolveProviderSettings,
 } = require("./state");
@@ -1698,9 +1698,10 @@ async function deliverForegroundResult(result, runContext, state = currentState(
   // /stop unwind: the SIGTERM (or pre-spawn abort) that follows a user cancel
   // is not a failure worth announcing — /stop already replied "Cancelled.".
   // The flag is consumed here (and re-cleared on the run's unwind) so it can
-  // never suppress a later run's genuine failure.
-  if (!result.ok && (state.cancelRequested || result.error?.code === "RUN_CANCELLED")) {
-    state.cancelRequested = false;
+  // never suppress a later run's genuine failure; it names the run it stopped.
+  const stoppedHere = cancelTargets(state.cancelRequested, runContext);
+  if (!result.ok && (stoppedHere || result.error?.code === "RUN_CANCELLED")) {
+    if (stoppedHere) state.cancelRequested = false;
     return { ok: true, suppressed: "cancelled" };
   }
   const diagnostic = providerRunDiagnostic(result, runContext);
@@ -1871,6 +1872,18 @@ function settleImmediateEffects(result, runContext, { state, store, capture }) {
 const STREAM_PREVIEW_THROTTLE_MS = 2500;
 const STREAM_PREVIEW_FOOTER = "\n\n⏳ working — /stop to cancel";
 
+// Runs whose interim narration (and, under /verbose, thinking) streams into
+// the chat: the person's own turns, and scheduled wake-ups (watches, wakeups,
+// crons). A scheduled run answers in the same room and settles through
+// deliverForegroundResult, which cleans the preview up exactly as for a
+// foreground turn; without it a watch-woken turn showed only "thinking..."
+// until the final answer. Background runs (dream, review, recall, learn,
+// compaction, subagents, side chats, silent runs) stay silent.
+const STREAM_PREVIEW_PURPOSES = new Set(["foreground", "scheduled"]);
+function streamPreviewAllowed(runContext) {
+  return STREAM_PREVIEW_PURPOSES.has(runContext?.purpose);
+}
+
 // Edited-in-place interim preview: each completed text block the provider
 // emits mid-run is appended to one throttled status message, so the user sees
 // the narration as it happens instead of silence. finalizeStreamPreview
@@ -1911,7 +1924,7 @@ function createStreamPreview({ state, store }) {
   };
 
   const appendChunk = (chunk, runContext) => {
-    if (!enabled || runContext?.purpose !== "foreground" || state.cancelRequested) return;
+    if (!enabled || !streamPreviewAllowed(runContext) || state.cancelRequested) return;
     state.streamBuffer = state.streamBuffer ? `${state.streamBuffer}\n\n${chunk}` : chunk;
     if (state.streamBuffer.length > 20000) state.streamBuffer = state.streamBuffer.slice(-16000);
     if (!state.streamInterval) state.streamInterval = setTimeout(flush, STREAM_PREVIEW_THROTTLE_MS);
@@ -1983,7 +1996,7 @@ function createForegroundService({ state, store, stopTyping, capture, ownsAdmiss
     },
     shouldAbort(runContext, { capture: isCapture } = {}) {
       if (isCapture || !ownsAdmissionLock) return false;
-      if (!state.cancelRequested) return false;
+      if (!cancelTargets(state.cancelRequested, runContext)) return false;
       state.cancelRequested = false;
       return true;
     },
@@ -2197,7 +2210,7 @@ async function executeAdmittedRun(runContext, state, store, capture, ownsAdmissi
     // A cancel flag that survived this run (e.g. /stop raced a run that
     // finished successfully anyway) must not leak into the next turn, where
     // it would falsely abort a queued run or mute a genuine failure.
-    if (ownsAdmissionLock) state.cancelRequested = false;
+    if (ownsAdmissionLock && cancelTargets(state.cancelRequested, runContext)) state.cancelRequested = false;
     if (tracksMainRun && state.activeRunContext === runContext) state.activeRunContext = null;
     stopTyping();
   }
@@ -2265,6 +2278,21 @@ function admitRunContext(prompt, cwd, replyToMsgId, opts = {}) {
   });
 }
 
+// What a message queued behind a long run is waiting for. A short wait is just
+// "Queued."; after two minutes it says what is running and how to stop it, so a
+// busy room never looks like a dead one (24 Sep: an hour behind a watch run).
+const QUEUED_DETAIL_AFTER_MS = 2 * 60 * 1000;
+function queuedNotice(activeRunContext, at = Date.now()) {
+  const since = Number(activeRunContext?.admittedAt);
+  if (!Number.isFinite(since) || at - since < QUEUED_DETAIL_AFTER_MS) return "Queued.";
+  const minutes = Math.floor((at - since) / 60000);
+  const header = String(activeRunContext.userPrompt || "").match(/^\[(Watch triggered|Watch expired|Watch check timing out|Scheduled cron|Scheduled wakeup) "([^"]*)"/);
+  const kind = header ? { "Watch triggered": "watch", "Watch expired": "watch", "Watch check timing out": "watch", "Scheduled cron": "scheduled job", "Scheduled wakeup": "wakeup" }[header[1]] : null;
+  const label = header && header[2].length > 60 ? `${header[2].slice(0, 59).trimEnd()}…` : header?.[2];
+  const what = kind ? `the ${kind} "${label}"` : "an earlier message";
+  return `Queued behind ${what} (running ${minutes} min). /stop cancels it.`;
+}
+
 function runAgent(prompt, cwd, replyToMsgId, opts = {}) {
   const state = currentState();
   const store = chatContext.getStore() || null;
@@ -2294,7 +2322,7 @@ function runAgent(prompt, cwd, replyToMsgId, opts = {}) {
     // task — noise. On a live call, send() is the TTS line: "Queued." would be
     // spoken to the caller. Both stay quiet and just deliver the real reply.
     if (currentAdapter()?.type !== "spaces" && !statusChatterMuted()) {
-      send(state.isCompacting ? "Compacting context, will pick this up next…" : "Queued.", { replyTo: replyToMsgId }).catch(() => {});
+      send(state.isCompacting ? "Compacting context, will pick this up next…" : queuedNotice(state.activeRunContext), { replyTo: replyToMsgId }).catch(() => {});
     }
     return deferred.promise;
   }
@@ -2389,7 +2417,9 @@ function runAgentSilent(prompt, cwd, label, opts = {}) {
 }
 
 module.exports = {
+  queuedNotice,
   admitRunContext,
+  streamPreviewAllowed,
   capturedTranscriptMetadata,
   decorateForegroundInvocation,
   createRunnerService,