@inetafrica/open-claudia 3.5.16 → 3.5.17

package/core/scheduler.js

@@ -15,11 +15,13 @@ const crypto = require("crypto");
 const fs = require("fs");
 const path = require("path");
 const cron = require("node-cron");
+const { scheduleTolerant } = require("./cron-schedule");
 const { spawn } = require("child_process");
 const CONFIG_DIR = require("../config-dir");
 
 const {
   CRONS_FILE,
+  CRON_LATE_TOLERANCE_MS,
   WORKSPACE,
   config,
 } = require("./config");
@@ -186,6 +188,16 @@ function deliveryPending(job) {
     && ["deferred", "failed", "running"].includes(job.status);
 }
 
+// The resume placeholder (see PLACEHOLDER_REPLY in core/runner): a scheduled
+// turn that answers only this did nothing.
+const PLACEHOLDER_REPLY = /^no response requested\.?$/i;
+const PLACEHOLDER_NUDGE = "Act on the prompt above now. Your first output must be a tool call or a real reply.";
+function isPlaceholderResult(result) {
+  if (result?.delivery?.suppressed === "placeholder") return true;
+  const text = String(result?.finalAnswerText || result?.text || "").trim();
+  return PLACEHOLDER_REPLY.test(text);
+}
+
 function providerIsRunnable(status) {
   if (!status || status.availability?.state !== "available") return false;
   if (status.compatibility?.state === "incompatible") return false;
@@ -210,11 +222,16 @@ function createSchedulerService(dependencies = {}) {
   const now = dependencies.now || Date.now;
   const setTimer = dependencies.setTimer || setTimeout;
   const clearTimer = dependencies.clearTimer || clearTimeout;
-  const scheduleCron = dependencies.scheduleCron || ((expression, callback) => cron.schedule(expression, callback, { noOverlap: true }));
+  // A late heartbeat must not cost the occurrence (core/cron-schedule).
+  const cronLateToleranceMs = Number.isFinite(dependencies.cronLateToleranceMs) ? dependencies.cronLateToleranceMs : CRON_LATE_TOLERANCE_MS;
+  const scheduleCron = dependencies.scheduleCron || ((expression, callback) => scheduleTolerant(expression, callback, {
+    cron: dependencies.cronLib || cron, noOverlap: true, toleranceMs: cronLateToleranceMs, label: `cron ${expression}`,
+  }));
   const validateCron = dependencies.validateCron || cron.validate;
   const runInChat = dependencies.runInChat || defaultRunInChat;
   const stateForUser = dependencies.getUserState || getUserState;
   const send = dependencies.send || defaultSend;
+  const ownerTargetFor = dependencies.ownerTarget || (() => require("./relationship").ownerTarget());
   const providerStatus = dependencies.providerStatus || defaultProviderStatus;
   const fallbackProviders = parseFallbacks(
     dependencies.fallbackProviders === undefined ? config.PROVIDER_FALLBACKS : dependencies.fallbackProviders,
@@ -521,12 +538,105 @@ function createSchedulerService(dependencies = {}) {
     return { ok: false, status: "failed", error: failure };
   }
 
+  // The chat scope a job runs (and reports) in: its room, its thread, its
+  // creator.
+  function jobChat(job, adapter) {
+    const canonicalUserId = job.canonicalUserId || canonicalForChannel(adapter.type, job.channelId);
+    const userId = String(job.userId || (adapter.type === "telegram" ? job.channelId : canonicalUserId || job.channelId || ""));
+    return {
+      adapter,
+      channelId: String(job.channelId),
+      canonicalUserId,
+      userId,
+      transport: adapter.type,
+      raw: null,
+      // Key the resumed conversation by the job's saved thread, not the live
+      // shared session. Matches captured project.name (projectDescriptor(job).name)
+      // so sameCapturedProject / getProjectKey resolve the right thread mid-run.
+      conversationKey: projectDescriptor(job).name,
+      // A job made in a chat thread answers in that thread: its notice, its
+      // typing indicator and its reply all go back into the thread.
+      threadId: jobThreadId(job),
+      // …but the thread is not the room. A job belongs to the room it was
+      // created in and must answer under THAT room's provider; without this the
+      // room overlay can't resolve and the run silently falls back to the
+      // creator's personal default — which is how a Codex room kept firing
+      // wakeups on Claude.
+      roomKey: conversationKeyFor(adapter.type, job.channelId),
+      // Rides only on triage-approval wakeups; the enforcer's reply vet honours
+      // the owner's one-off "handle this request" grant through it.
+      triageApprovalId: job.triageApprovalId || "",
+    };
+  }
+
+  // A job that will not run (a one-shot dead-lettered, or a recurring
+  // occurrence that failed for good) says so once, in its own conversation, or
+  // to the owner when that channel is gone. Until now only `cron-list` showed
+  // "DEAD: will not fire".
+  function jobDeathNotice(job, failure, recurring) {
+    const label = String(job.label || job.prompt || job.id).replace(/\s+/g, " ").slice(0, 60);
+    const code = failure?.code || "SCHEDULED_RUN_FAILED";
+    const kind = job.check ? "Watch" : job.kind === "wakeup" ? "Wake-up" : "Scheduled job";
+    if (recurring) {
+      return `⚠️ ${kind} "${label}" failed ${job.attemptCount || 1} times this time (${code}); that run is skipped. It stays scheduled and runs again at its next time (open-claudia cron-list).`;
+    }
+    const rearm = job.check
+      ? "open-claudia watch-add \"<check>\" \"<prompt>\""
+      : job.kind === "wakeup" ? "open-claudia schedule-wakeup <when> \"<prompt>\"" : "open-claudia cron-add \"<schedule>\" \"<prompt>\"";
+    return `⚠️ ${kind} "${label}" gave up (${code}) and will not fire. To re-arm it: ${rearm} (${job.id}).`;
+  }
+
+  function notifyJobDeath(job, failure, recurring) {
+    const text = jobDeathNotice(job, failure, recurring);
+    console.warn(`[scheduler] ${job.id}: ${text}`);
+    const adapter = resolveAdapter(job);
+    const delivery = adapter && job.channelId
+      ? Promise.resolve(runInChat(jobChat(job, adapter), () => send(text)))
+      : Promise.resolve(ownerTargetFor()).then((target) => {
+        const ownerAdapter = target && (adapters.find((a) => a.id === target.adapter) || adapters.find((a) => a.type === target.adapter));
+        if (!ownerAdapter) throw new Error("no owner channel");
+        return ownerAdapter.send(target.channelId, text);
+      });
+    return delivery.catch((error) => console.warn(`[scheduler] ${job.id}: death notice not delivered: ${error?.message || error}`));
+  }
+
   function markFailure(job, failure, options = {}) {
     const latest = jobsStore.get(job.id) || job;
     const attemptCount = options.attemptAlreadyCounted
       ? Math.max(1, latest.attemptCount || 0)
       : (latest.attemptCount || 0) + 1;
     const dead = attemptCount >= (latest.maxAttempts || 1);
+    // A recurring job keeps its schedule: the failed occurrence is recorded and
+    // skipped, the next one starts fresh. Only a one-shot dead-letters.
+    if (dead && !isOneShot(latest)) {
+      const failed = stableFailure(failure);
+      const advance = {
+        status: "pending",
+        disabled: false,
+        occurrenceId: occurrenceIdFactory(latest),
+        attemptCount: 0,
+        busyDeferralCount: 0,
+        nextAttemptAt: null,
+        lastFireAt: now(),
+        lastFireOk: false,
+        lastError: failed,
+        failedOccurrences: (Number(latest.failedOccurrences) || 0) + 1,
+        lastFailedOccurrenceId: latest.occurrenceId || null,
+        watchTriggeredOccurrenceId: null,
+        watchTriggeredAt: null,
+        watchExpired: false,
+        watchCheckTimingOut: false,
+        watchExtraHits: 0,
+        watchLastHitAt: null,
+        watchLastClearAt: null,
+        advisoryOccurrenceId: null,
+      };
+      const advanced = jobsStore.update(job.id, advance) || { ...latest, ...advance };
+      unscheduleJob(job.id);
+      scheduleJob(advanced);
+      notifyJobDeath({ ...latest, attemptCount }, failed, true);
+      return { ok: false, status: "failed", occurrenceSkipped: true, job: advanced, error: failed };
+    }
     const patch = {
       status: dead ? "dead-letter" : "failed",
       disabled: dead,
@@ -538,7 +648,10 @@ function createSchedulerService(dependencies = {}) {
     };
     const updated = jobsStore.update(job.id, patch) || { ...latest, ...patch };
     if (!dead) armRetry(updated);
-    else unscheduleJob(job.id);
+    else {
+      unscheduleJob(job.id);
+      notifyJobDeath(updated, updated.lastError, false);
+    }
     return { ok: false, status: updated.status, job: updated, error: updated.lastError };
   }
 
@@ -722,32 +835,8 @@ function createSchedulerService(dependencies = {}) {
       try { return markFailure(job, { code: "SCHEDULED_ADAPTER_UNAVAILABLE", message: "Saved channel adapter is unavailable" }); }
       catch (error) { return keepRetrying(job, error); }
     }
-    const canonicalUserId = job.canonicalUserId || canonicalForChannel(adapter.type, job.channelId);
-    const userId = String(job.userId || (adapter.type === "telegram" ? job.channelId : canonicalUserId || job.channelId || ""));
-    const chat = {
-      adapter,
-      channelId: String(job.channelId),
-      canonicalUserId,
-      userId,
-      transport: adapter.type,
-      raw: null,
-      // Key the resumed conversation by the job's saved thread, not the live
-      // shared session. Matches captured project.name (projectDescriptor(job).name)
-      // so sameCapturedProject / getProjectKey resolve the right thread mid-run.
-      conversationKey: projectDescriptor(job).name,
-      // A job made in a chat thread answers in that thread: its notice, its
-      // typing indicator and its reply all go back into the thread.
-      threadId: jobThreadId(job),
-      // …but the thread is not the room. A job belongs to the room it was
-      // created in and must answer under THAT room's provider; without this the
-      // room overlay can't resolve and the run silently falls back to the
-      // creator's personal default — which is how a Codex room kept firing
-      // wakeups on Claude.
-      roomKey: conversationKeyFor(adapter.type, job.channelId),
-      // Rides only on triage-approval wakeups; the enforcer's reply vet honours
-      // the owner's one-off "handle this request" grant through it.
-      triageApprovalId: job.triageApprovalId || "",
-    };
+    const chat = jobChat(job, adapter);
+    const { canonicalUserId } = chat;
 
     return runInChat(chat, async () => {
       noteLegacyCreatorOnce(job);
@@ -837,8 +926,23 @@ function createSchedulerService(dependencies = {}) {
         } catch (_) { /* advisory only */ }
       }
       let result;
-      try { result = await runInProvider(prompt, runContext.cwd, null, { ...runOptions, runContext }); }
-      catch (error) {
+      try {
+        result = await runInProvider(prompt, runContext.cwd, null, { ...runOptions, runContext });
+        // A scheduled turn whose whole reply is the resume placeholder did
+        // nothing (the runner never posts it). Nudge it once, in the same
+        // session; never more than once.
+        if (terminalRunSucceeded(result) && isPlaceholderResult(result)) {
+          const sessionId = result.sessionId || runContext.sessionId || null;
+          console.warn(`[scheduler] ${job.id}: the scheduled turn answered "No response requested." — re-running once with a nudge`);
+          const retryPrompt = sessionId ? PLACEHOLDER_NUDGE : `${prompt}\n\n${PLACEHOLDER_NUDGE}`;
+          const retryOptions = { ...runOptions, fresh: !sessionId, resumeSessionId: sessionId };
+          const retryContext = admit(retryPrompt, project.dir, null, retryOptions);
+          result = await runInProvider(retryPrompt, retryContext.cwd, null, { ...retryOptions, runContext: retryContext });
+          if (terminalRunSucceeded(result) && isPlaceholderResult(result)) {
+            console.warn(`[scheduler] ${job.id}: the nudged re-run answered "No response requested." too — not retrying again`);
+          }
+        }
+      } catch (error) {
         try { return markFailure(running, error, { attemptAlreadyCounted: true }); }
         catch (persistError) { return keepRetrying(running, persistError); }
       }
@@ -920,13 +1024,10 @@ function createSchedulerService(dependencies = {}) {
       const fireAt = Number(job.fireAt || 0);
       const overdue = now() - fireAt;
       if (overdue > missedGraceMs) {
+        const lastError = { code: "MISSED_WAKEUP_EXPIRED", message: "Wakeup exceeded the missed-fire grace window" };
         try {
-          jobsStore.update(job.id, {
-            status: "dead-letter",
-            disabled: true,
-            nextAttemptAt: null,
-            lastError: { code: "MISSED_WAKEUP_EXPIRED", message: "Wakeup exceeded the missed-fire grace window" },
-          });
+          jobsStore.update(job.id, { status: "dead-letter", disabled: true, nextAttemptAt: null, lastError });
+          notifyJobDeath(job, lastError, false);
         } catch (_) {}
         return false;
       }

package/core/system-prompt.js

@@ -402,13 +402,72 @@ function buildCoreInstructions(opts = {}) {
   const core = mandatoryPromptPart("coreInstructions", buildCoreInstructionsUncached);
   if (!core.trim()) throw new PromptConstructionError("coreInstructions", new Error("core instructions were empty"));
   coreInstructionsByIdentity.set(key, core);
+  // Which lessons this session's (frozen) core carries, and since when: a
+  // lesson learned later reaches the session through newLessonsSection.
+  let lessonIds = new Set();
+  try { lessonIds = new Set(require("./lessons").injectedLessons().map((lesson) => lesson.id)); } catch (_) { /* no lessons */ }
+  coreLessonsByIdentity.set(key, { at: Date.now(), ids: lessonIds, shown: new Set() });
   while (coreInstructionsByIdentity.size > 100) {
-    coreInstructionsByIdentity.delete(coreInstructionsByIdentity.keys().next().value);
+    const oldest = coreInstructionsByIdentity.keys().next().value;
+    coreInstructionsByIdentity.delete(oldest);
+    coreLessonsByIdentity.delete(oldest);
   }
   return core;
 }
 
-function buildSpeakerContextBlock() {
+// Lessons are part of the core instructions, which stay byte-stable for a
+// session, so a lesson added after the session started never reached it.
+// On the session's next turn, lessons created since its core was built (and
+// not in it) ride the per-turn block once each.
+const coreLessonsByIdentity = new Map(); // captured run identity -> { at, ids, shown }
+
+function newLessonsSection(opts = {}) {
+  let key;
+  try { key = promptDedupeIdentity(opts); } catch (_) { return ""; }
+  const base = coreLessonsByIdentity.get(key);
+  if (!base) return "";
+  let fresh = [];
+  try {
+    const lessonsLib = require("./lessons");
+    fresh = lessonsLib.listLessons()
+      .filter((lesson) => !base.ids.has(lesson.id) && !base.shown.has(lesson.id))
+      .filter((lesson) => Date.parse(lesson.created || "") >= base.at)
+      .reverse(); // oldest first
+    const lines = [];
+    let used = 0;
+    for (const lesson of fresh) {
+      const line = lessonsLib.lessonLine(lesson);
+      if (used + line.length + 1 > lessonsLib.MAX_LESSONS_CHARS) break;
+      lines.push(line);
+      used += line.length + 1;
+      base.shown.add(lesson.id);
+    }
+    if (!lines.length) return "";
+    return ["## New standing rules since this conversation started:", "Learned after this conversation began; treat them exactly like the Lessons learned in your instructions.", ...lines].join("\n");
+  } catch (_) { return ""; }
+}
+
+// The team roster and the slash-command list hardly change and are a few
+// thousand chars each, so like the task section they ride only the first turn
+// of a session per conversation (restart, new conversation, compaction); the
+// session still holds them afterwards. A build that names neither a session
+// nor a run (or has no provider yet) always includes them.
+const channelExtrasShownFor = new Map(); // `${adapterId}:${conversationKey}` -> captured run identity
+
+function channelExtrasDue(adapter, channelId, opts) {
+  let identity;
+  try {
+    const run = promptRunIdentity(opts);
+    if (!run.sessionId && !run.runId) return true;
+    identity = promptDedupeIdentity(opts);
+  } catch (_) { return true; }
+  const key = dedupeScope(adapter, channelId, opts);
+  if (channelExtrasShownFor.get(key) === identity) return false;
+  channelExtrasShownFor.set(key, identity);
+  return true;
+}
+
+function buildSpeakerContextBlock(opts = {}) {
   const adapter = currentAdapter();
   const channelId = currentChannelId();
   const channelLabel = adapter
@@ -471,7 +530,8 @@ function buildSpeakerContextBlock() {
     blocks.push("", "## Speaker", "No named speaker profile is available for this turn.");
   }
 
-  const roster = people.roster();
+  const extrasDue = channelExtrasDue(adapter, channelId, opts);
+  const roster = extrasDue ? people.roster() : [];
   if (roster.length) {
     const lines = roster.map((person) => {
       const handles = (person.handles || []).map((handle) => `${handle.adapter}:${handle.channelId}`).join(", ") || "(no handles)";
@@ -481,7 +541,7 @@ function buildSpeakerContextBlock() {
     blocks.push("", "## Team", ...lines);
   }
 
-  const commands = commandsRegistry.publicCommands();
+  const commands = extrasDue ? commandsRegistry.publicCommands() : [];
   if (commands.length) {
     blocks.push(
       "",
@@ -513,11 +573,12 @@ function buildSpeakerContextBlock() {
 // the prompt-cache prefix and re-bills the full history at write price
 // instead of 0.1x read price. Keep buildCoreInstructions() byte-stable
 // within a session; put anything that flips between turns here.
-// The full task tree is large and rides the (uncached) tail of every
-// prompt, so inject it only once per session: on the first turn after a
-// bot restart, a new conversation, or a compaction (the captured run identity
-// changes in all three cases). Later turns get a one-line count; the
-// agent runs `open-claudia task list` when it needs detail.
+// The task section rides the tail of the prompt, so inject it only once per
+// session: on the first turn after a bot restart, a new conversation, or a
+// compaction (the captured run identity changes in all three cases). It shows
+// this conversation's own tasks and one line about the rest of the channel
+// (tasks.formatConversationSection, capped). Later turns get a one-line
+// count; the agent runs `open-claudia task list` when it needs detail.
 const taskTreeInjectedFor = new Map(); // `${adapterId}:${conversationKey}` -> captured run identity
 
 function buildDynamicContextBlock(opts = {}) {
@@ -539,6 +600,8 @@ function buildDynamicContextBlock(opts = {}) {
     `- Session: ${identity.sessionId ? "resuming existing conversation" : "new conversation"}`,
     ...parallelConversationLines(opts.state || currentState(), opts.runContext),
   ];
+  const lessonsSince = newLessonsSection({ ...opts, state });
+  if (lessonsSince) lines.push("", lessonsSince);
   if (adapter && channelId) {
     // Decision cards this bot asked in this conversation that still wait: it
     // closes the ones answered in words or no longer needed. Never breaks the
@@ -554,8 +617,8 @@ function buildDynamicContextBlock(opts = {}) {
       const key = dedupeScope(adapter, channelId, opts);
       if (taskTreeInjectedFor.get(key) !== dedupeIdentity) {
         taskTreeInjectedFor.set(key, dedupeIdentity);
-        const tree = tasksStore.formatForInjection(adapter.id, channelId, { showIds: true });
-        lines.push("", "## Pending tasks", "Ranked by recent activity (`updatedAt`). The most-recently-worked items show in full; colder ones are title-only; stale ones (untouched >2w) are batched at the bottom — they're likely finished or abandoned, so close them with `open-claudia task done <id>` or reopen by working them. Mark a task in_progress when you actually start it and done when finished, so this ranking stays honest. If something in our conversation shows a task is already finished, proactively offer to close it. Shown once per session — run `open-claudia task list` for the full tree.", "", tree);
+        const threadId = opts.runContext?.threadId || currentThreadId() || null;
+        lines.push("", tasksStore.formatConversationSection(adapter.id, channelId, { threadId, showIds: true }));
       } else {
         const inProgress = pending.filter((task) => task.status === "in_progress").length;
         lines.push("", `## Pending tasks: ${pending.length} open${inProgress > 0 ? ` (${inProgress} in progress)` : ""} — run \`open-claudia task list\` for the tree. Keep statuses current as you work.`);
@@ -568,9 +631,18 @@ function buildDynamicContextBlock(opts = {}) {
 // Context-pack router: FTS-match the incoming message against packs and
 // inject hits into the per-turn block. Rides the user message (NOT the
 // system prompt) for the same cache reason as the task tree above. Each
-// pack body is injected once per (channel, session, pack-version) — once
-// it's in the conversation the model keeps it until compaction.
-const packsInjectedFor = new Map(); // `${adapterId}:${conversationKey}:${dir}` -> `${sessionId}:${updated}`
+// pack body is injected once per (conversation, session, pack content) —
+// once it's in the conversation the model keeps it until compaction. The
+// content is what the block renders (name, description, parent, sections),
+// not `updated`: recordApplied, setParent, setSkill and setKind bump
+// `updated` on every use or dream nesting and used to re-inject the whole
+// pack with nothing new in it.
+const packsInjectedFor = new Map(); // `${adapterId}:${conversationKey}:${dir}` -> `${run identity}:${content hash}`
+
+function packContentHash(pack) {
+  const material = JSON.stringify([pack.name, pack.description, pack.parent || null, pack.sections || {}]);
+  return require("crypto").createHash("sha1").update(material).digest("hex").slice(0, 16);
+}
 const PACK_INJECT_MAX_CHARS = 4000;
 const DEFAULT_MEMORY_RECALL_MAX_CHARS = 9000;
 const EXTRACTIVE_LINES_PER_SECTION = 4;
@@ -782,10 +854,10 @@ function buildPackBlock(matches, budget, opts = {}) {
       if (!pack) continue;
       used.push(m.dir);
       const key = `${dedupeScope(adapter, channelId, opts)}:${m.dir}`;
-      const stamp = `${runIdentity}:${pack.updated}`;
+      const stamp = `${runIdentity}:${packContentHash(pack)}`;
       const pending = pendingRemindersFor("pack", m.dir);
       const pendingText = pending.length ? renderReminders(pending) : "";
-      // Inject a pack's body once per (channel, session, version). A
+      // Inject a pack's body once per (conversation, session, content). A
       // compaction mints a new session id, which changes the stamp and
       // forces a fresh re-injection on the next turn (same mechanism
       // as the task tree), so the pack survives compaction without paying
@@ -1421,6 +1493,7 @@ module.exports = {
   PromptConstructionError,
   buildCoreInstructions,
   buildOptionalRecallContext,
+  buildPackBlock,
   formatPackForContext,
   buildDynamicContextBlock,
   buildExternalModeBlock,