@inetafrica/open-claudia 3.5.16 → 3.5.17

package/core/dream.js

@@ -12,6 +12,7 @@
 const fs = require("fs");
 const path = require("path");
 const cron = require("node-cron");
+const { scheduleTolerant } = require("./cron-schedule");
 const { atomicWriteFileSync } = require("./fsutil");
 const { memoryMutationQueue } = require("./memory-mutation-queue");
 
@@ -937,20 +938,40 @@ function writeDreamReport(data) {
 
 // Task-hygiene pass: surface tasks gone cold for the owner to decide on.
 // Flag-and-ask only — tasks are user intent, so dream NEVER edits or deletes
-// them; it just lists the stalest few in the morning report. Reports against
-// the owner's Telegram channel (where the dream summary lands).
+// them; it just lists the stalest few in the morning report. It covers every
+// task list on this bot (tasks.taskLists): task kinds are owner-only, so each
+// list is the owner's, whether it lives in Telegram, a Kazee chat or another
+// channel. (It used to read only the Telegram CHAT_ID list, so an owner who
+// works in Kazee never got a report.) At most STALE_REPORT_MAX task lines in
+// all, shared out across the lists, each naming its list.
 const STALE_REPORT_MAX = Number(process.env.DREAM_STALE_TASK_MAX) || 8;
-function staleTaskReport() {
+function staleTaskReport(opts = {}) {
   try {
     const tasks = require("./tasks");
-    const { CHAT_ID } = require("./config");
-    if (!CHAT_ID) return "";
-    const stale = tasks.staleRoots("telegram", String(CHAT_ID));
-    if (!stale.length) return "";
-    const shown = stale.slice(0, STALE_REPORT_MAX);
-    const lines = shown.map((s) => `   - ${s.content}  (${s.id}) · ${s.idleDays}d idle`);
-    const more = stale.length > shown.length ? `\n   …and ${stale.length - shown.length} more` : "";
-    return `🧹 ${stale.length} task${stale.length === 1 ? "" : "s"} have gone cold (untouched >${tasks.STALE_DAYS}d). Worth closing or reviving?\n${lines.join("\n")}${more}\nClose with \`open-claudia task done <id>\`, or tell me to.`;
+    const lists = tasks.taskLists(opts.dir)
+      .map((list) => ({ ...list, stale: tasks.staleRootsOf(tasks.loadFile(list.file), { now: opts.now }) }))
+      .filter((list) => list.stale.length > 0)
+      .sort((a, b) => b.stale.length - a.stale.length);
+    if (!lists.length) return "";
+    const total = lists.reduce((n, list) => n + list.stale.length, 0);
+    const max = Number.isFinite(opts.max) ? opts.max : STALE_REPORT_MAX;
+    // Round-robin, oldest first within each list, so every list gets a line.
+    const shown = [];
+    for (let i = 0; shown.length < max; i += 1) {
+      const before = shown.length;
+      for (const list of lists) {
+        if (shown.length >= max) break;
+        if (list.stale[i]) shown.push({ list, task: list.stale[i] });
+      }
+      if (shown.length === before) break;
+    }
+    const clip = (text) => (String(text).length > 80 ? `${String(text).slice(0, 79)}…` : String(text));
+    const lines = shown.map(({ list, task }) => `   - [${list.label}] ${clip(task.content)}  (${task.id}) · ${task.idleDays}d idle`);
+    const where = lists.length === 1 ? `in ${lists[0].label}` : `across ${lists.length} task lists`;
+    const more = total > shown.length
+      ? `\n   …and ${total - shown.length} more (${lists.map((list) => `${list.label}: ${list.stale.length}`).join(" · ")})`
+      : "";
+    return `🧹 ${total} task${total === 1 ? "" : "s"} have gone cold (untouched >${tasks.STALE_DAYS}d) ${where}. Worth closing or reviving?\n${lines.join("\n")}${more}\nClose with \`open-claudia task done <id>\` in that chat, or tell me to.`;
   } catch (e) { return ""; }
 }
 
@@ -1566,37 +1587,123 @@ const defaultDreamService = createDreamService();
 const runDream = defaultDreamService.runDream;
 const previewDream = defaultDreamService.previewDream;
 
-// In-bot scheduler: one quiet-hours cron, reporting to the owner's
-// Telegram chat. When the dream summary is on (default) it posts a short
-// note after every run — including the charming "all tidy" line when
-// nothing changed. /dreamsummary off mutes it to console only.
-function initDream(adapters) {
-  if (!enabled()) return;
-  if (!cron.validate(DREAM_CRON)) {
-    console.error(`dream: invalid DREAM_CRON "${DREAM_CRON}" — dream disabled`);
-    return;
+// Where the dream summary goes: DREAM_SUMMARY_TO ("<adapter>:<channelId>") if
+// set; else the owner's primary handle from the people roster when its
+// adapter is loaded (a Kazee user-id handle resolves to the owner's DM); else
+// the Telegram owner chat (CHAT_ID). It used to go only to Telegram, so a
+// Kazee-only owner never saw it. null = nowhere to send.
+async function dreamSummaryTarget(adapters, deps = {}) {
+  const list = adapters || [];
+  const find = (name) => list.find((a) => a.id === name) || list.find((a) => a.type === name) || null;
+  const to = String(deps.summaryTo ?? process.env.DREAM_SUMMARY_TO ?? config.DREAM_SUMMARY_TO ?? "").trim();
+  if (to) {
+    const cut = to.indexOf(":");
+    const adapter = cut > 0 ? find(to.slice(0, cut)) : null;
+    if (adapter && to.slice(cut + 1)) return { adapter, channelId: to.slice(cut + 1), via: "DREAM_SUMMARY_TO" };
+    console.warn(`dream: DREAM_SUMMARY_TO "${to}" names no loaded adapter; using the owner's channel`);
   }
-  cron.schedule(DREAM_CRON, async () => {
-    try {
-      const res = await runDream({ trigger: "cron" });
-      if (res.skipped) { console.log(`dream: skipped — ${res.skipped}`); return; }
-      console.log(`dream: applied ${res.applied.length} change(s)`);
-      if (!summaryEnabled()) { console.log("dream: summary muted (DREAM_SUMMARY=off)"); return; }
-      if (!res.message) return;
-      const { CHAT_ID } = require("./config");
-      const tg = (adapters || []).find((a) => a.type === "telegram");
-      if (tg && CHAT_ID) await tg.send(CHAT_ID, res.message);
-    } catch (e) {
-      console.error("dream: run failed:", e.message);
+  try {
+    const peopleLib = deps.people || require("./people");
+    const owner = (peopleLib.owners() || [])[0];
+    const handles = owner?.handles || [];
+    const handle = owner?.primaryChannel
+      ? handles.find((h) => h.adapter === owner.primaryChannel.adapter && String(h.channelId) === String(owner.primaryChannel.channelId))
+      : null;
+    const adapter = handle ? find(handle.adapter) : null;
+    if (adapter) {
+      const resolve = deps.resolveHandle || require("./relationship").resolveHandleSendTarget;
+      const target = await resolve(handle);
+      if (target?.channelId) return { adapter, channelId: String(target.channelId), via: "owner primary handle" };
     }
+  } catch (e) { /* fall back to Telegram */ }
+  const chatId = deps.chatId !== undefined ? deps.chatId : require("./config").CHAT_ID;
+  const tg = find("telegram");
+  if (tg && chatId) return { adapter: tg, channelId: String(chatId), via: "TELEGRAM_CHAT_ID" };
+  return null;
+}
+
+// One scheduled dream (cron or catch-up) with its summary.
+async function runScheduledDream(trigger, adapters, deps = {}) {
+  try {
+    const res = await (deps.runDream || runDream)({ trigger });
+    if (res.skipped) { console.log(`dream: skipped — ${res.skipped}`); return res; }
+    console.log(`dream: applied ${(res.applied || []).length} change(s)`);
+    if (!summaryEnabled()) { console.log("dream: summary muted (DREAM_SUMMARY=off)"); return res; }
+    if (!res.message) return res;
+    const target = await dreamSummaryTarget(adapters, deps);
+    if (!target) { console.warn("dream: no channel to send the summary to"); return res; }
+    await target.adapter.send(target.channelId, res.message);
+    return res;
+  } catch (e) {
+    console.error("dream: run failed:", e.message);
+    return { failed: e.message };
+  }
+}
+
+// Catch-up: a dream that has not run for more than DREAM_CATCHUP_HOURS (26 h)
+// runs once now, checked at boot and hourly — a night the bot was down or the
+// cron slot was missed is not lost. At most one catch-up attempt per window
+// (stamped in the dream state, so a failing dream is not retried every hour),
+// and never beside a running dream.
+const DREAM_CATCHUP_MS = (Number(process.env.DREAM_CATCHUP_HOURS) || 26) * 3600000;
+function dreamOverdue(state, nowMs, windowMs = DREAM_CATCHUP_MS) {
+  const last = Date.parse(state?.lastRun || "");
+  if (Number.isFinite(last) && nowMs - last <= windowMs) return false;
+  const tried = Date.parse(state?.lastCatchUpAt || "");
+  return !(Number.isFinite(tried) && nowMs - tried <= windowMs);
+}
+
+function createDreamCatchUp(adapters, deps = {}) {
+  const now = deps.now || Date.now;
+  const readState = deps.readState || readDreamState;
+  const writeState = deps.writeState || writeDreamState;
+  const isDreaming = deps.isDreaming || defaultDreamService.isDreaming;
+  let inFlight = null;
+  return async function catchUp(reason = "check") {
+    if (inFlight || isDreaming()) return { skipped: "a dream is already running" };
+    const state = readState() || {};
+    if (!dreamOverdue(state, now())) return { skipped: "not overdue" };
+    writeState({ ...state, lastCatchUpAt: new Date(now()).toISOString() });
+    console.log(`dream: catch-up (${reason}) — last run ${state.lastRun || "never"}`);
+    inFlight = runScheduledDream("catch-up", adapters, deps);
+    try { return await inFlight; } finally { inFlight = null; }
+  };
+}
+
+// In-bot scheduler: one quiet-hours cron (tolerating a late start up to
+// DREAM_LATE_TOLERANCE_MS, see core/cron-schedule), a boot + hourly catch-up
+// check, and the summary to the owner's channel (dreamSummaryTarget). When the
+// dream summary is on (default) it posts a short note after every run —
+// including the charming "all tidy" line when nothing changed.
+// /dreamsummary off mutes it to console only.
+function initDream(adapters, deps = {}) {
+  if (!enabled()) return null;
+  const cronLib = deps.cron || cron;
+  if (!cronLib.validate(DREAM_CRON)) {
+    console.error(`dream: invalid DREAM_CRON "${DREAM_CRON}" — dream disabled`);
+    return null;
+  }
+  const { DREAM_LATE_TOLERANCE_MS } = require("./config");
+  const toleranceMs = Number.isFinite(deps.toleranceMs) ? deps.toleranceMs : DREAM_LATE_TOLERANCE_MS;
+  const task = scheduleTolerant(DREAM_CRON, () => runScheduledDream("cron", adapters, deps), {
+    cron: cronLib, toleranceMs, noOverlap: true, label: "dream",
   });
-  console.log(`dream: scheduled (${DREAM_CRON}, provider policy tier ${dreamTier()}, effort ${DREAM_EFFORT}, introspect ${introspectEnabled() ? "on" : "off"})`);
+  const catchUp = createDreamCatchUp(adapters, deps);
+  const setTimer = deps.setTimer || setTimeout;
+  const setRepeat = deps.setInterval || setInterval;
+  const boot = setTimer(() => { catchUp("boot").catch(() => {}); }, Number.isFinite(deps.bootDelayMs) ? deps.bootDelayMs : 60000);
+  const hourly = setRepeat(() => { catchUp("hourly").catch(() => {}); }, 3600000);
+  boot?.unref?.();
+  hourly?.unref?.();
+  console.log(`dream: scheduled (${DREAM_CRON}, late tolerance ${Math.round(toleranceMs / 60000)} min, provider policy tier ${dreamTier()}, effort ${DREAM_EFFORT}, introspect ${introspectEnabled() ? "on" : "off"})`);
+  return { task, catchUp };
 }
 
 module.exports = {
   createDreamService, previewDream, runDream, initDream, buildDreamPrompt, parseDream, applyDream, manageAbilityTiers, nestPrefixFamilies, dreamTimeoutMs,
   buildIntrospectionPrompt, parseIntrospection, applyIntrospection, writeDreamReport,
-  summaryDelta, healthOf, mergeClusters, selectDumpDirs, journalBackfillDedupe,
+  summaryDelta, healthOf, mergeClusters, selectDumpDirs, journalBackfillDedupe, staleTaskReport,
+  dreamSummaryTarget, runScheduledDream, dreamOverdue, createDreamCatchUp, DREAM_CATCHUP_MS,
   coRescueEdgesPhase, negativeHebbianPhase, readDreamState, writeDreamState,
   enabled, summaryEnabled, introspectEnabled, selfApplyEnabled, dreamTier,
   DREAM_CRON, DREAM_EFFORT, DREAM_OUTPUT_SCHEMA, INTROSPECTION_OUTPUT_SCHEMA,

package/core/guardrail.js

@@ -59,6 +59,10 @@ const MED_OPENER = /^(?:always|don'?t|do not|make sure|be sure|remember to|prefe
 
 // Junk that pattern-matches a directive but is never a rule.
 const STOP_RULES = new Set(["never mind", "nevermind", "stop it", "never ever", "don't worry", "do not worry"]);
+// Reassurances open like directives but never carry a rule, however they go
+// on: "Don't worry so much about that.", "Never mind, I found it." (the
+// latter would otherwise read as a high-tier never-directive).
+const REASSURANCE = /^(?:don'?t worry|do not worry|never ?mind)\b/i;
 
 function splitSentences(text) {
   return String(text || "")
@@ -92,6 +96,7 @@ function ruleOk(rule) {
   if (!rule || rule.length < MIN_RULE_CHARS) return false;
   const low = rule.toLowerCase();
   if (STOP_RULES.has(low)) return false;
+  if (REASSURANCE.test(rule)) return false;
   if (low.split(/\s+/).length < MIN_RULE_WORDS) return false;
   return true;
 }

package/core/handlers.js

@@ -7,7 +7,7 @@ const path = require("path");
 const cronLib = require("node-cron");
 const { execSync } = require("child_process");
 const {
-  WORKSPACE, FULL_PATH, AUTO_COMPACT_TOKENS, CONFIG_DIR,
+  WORKSPACE, FULL_PATH, CONFIG_DIR,
   config, saveEnvKey,
   CHAT_ID, discoverProviderExecutable, SOUL_FILE,
 } = require("./config");
@@ -38,7 +38,7 @@ const scheduler = require("./scheduler");
 const skillsLib = require("./skills");
 const packsLib = require("./packs");
 const {
-  admitRunContext, runAgent, compactActiveSession, getActiveSessionId, effectiveCompactThreshold,
+  admitRunContext, runAgent, compactActiveSession, getActiveSessionId, effectiveCompactThreshold, defaultCompactTokens,
 } = require("./runner");
 const {
   getClaudeOAuthToken, saveClaudeOAuthToken,
@@ -93,6 +93,7 @@ function cancelledQueueResult(item, reason) {
 function dropLaneQueue(lane, reason) {
   if (!lane) return [];
   const queued = lane.messageQueue.splice(0);
+  try { require("./turn-journal").dropQueued(lane.key, queued.map((item) => item?.runContext?.runId).filter(Boolean)); } catch (_) {}
   lane.waitingForSlot = false;
   for (const item of queued) {
     try { item?.disposeCallListener?.(); } catch (_) {}
@@ -592,7 +593,8 @@ register({
     if (!ownerEnv(env)) return;
     await send("Going offline for a quick restart — back in a moment.");
     try { require("./restart-reason").recordExitReason("User /restart command", { code: 0 }); } catch (e) {}
-    setTimeout(() => process.exit(0), 1000);
+    // Running turns get DRAIN_TIMEOUT_S to finish; the rest resume after boot.
+    setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 1000);
   },
 });
 
@@ -854,7 +856,7 @@ register({
       try { require("./boot-health").recordPendingDoctor({ reason: "source overlay upgrade", from: CURRENT_VERSION, to: newVersion }); } catch (e) {}
       try { require("./safe-mode").clearCrashLoop(); } catch (e) {}
       try { require("./restart-reason").recordExitReason(`User /upgrade → v${newVersion} (source refresh)`, { code: 0 }); } catch (e) {}
-      setTimeout(() => process.exit(0), 2000);
+      setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 2000);
       return;
     }
     try { process.chdir(process.env.HOME || require("os").homedir()); } catch (e) {}
@@ -918,7 +920,7 @@ register({
       await send(`Upgrade failed:\n${errOutput}`);
       return;
     }
-    setTimeout(() => process.exit(0), 2000);
+    setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 2000);
   },
 });
 
@@ -982,7 +984,7 @@ register({
       try { require("./boot-health").recordPendingDoctor({ reason: "downgrade overlay", from: CURRENT_VERSION, to: resolved }); } catch (e) {}
       try { safeModeLib.clearCrashLoop(); } catch (e) {}
       try { require("./restart-reason").recordExitReason(`User /downgrade → v${resolved} (source refresh)`, { code: 0 }); } catch (e) {}
-      setTimeout(() => process.exit(0), 2000);
+      setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 2000);
       return;
     }
     try { process.chdir(process.env.HOME || require("os").homedir()); } catch (e) {}
@@ -1002,7 +1004,7 @@ register({
       await send(`Downgrade failed:\n${errOutput}`);
       return;
     }
-    setTimeout(() => process.exit(0), 2000);
+    setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 2000);
   },
 });
 
@@ -1020,7 +1022,7 @@ register({
       safeModeLib.requestContinue();
       await send("Override armed: the next boot runs normally even if the substrate is missing (keyword-only memory) and the crash-loop counter resets. Restarting now...");
       try { require("./restart-reason").recordExitReason("User /safemode continue override", { code: 0 }); } catch (e) {}
-      setTimeout(() => process.exit(0), 1500);
+      setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 1500);
       return;
     }
     if (safeModeLib.isSafeMode()) {
@@ -1575,7 +1577,7 @@ function formatCompactWindow(state) {
   const fmt = (n) => n >= 1000 ? (n / 1000).toFixed(0) + "k" : String(n);
   const cw = state.settings?.compactWindow;
   if (cw === 0) return "off";
-  if (cw == null) return `default (${fmt(AUTO_COMPACT_TOKENS)})`;
+  if (cw == null) return `default (${fmt(defaultCompactTokens(getProjectKey(state)))})`;
   return fmt(cw);
 }
 
@@ -1726,6 +1728,16 @@ function stopLane(state, lane) {
 
 const STOP_DROP_REASON = "Dropped by /stop before it started";
 
+// /stop never silently loses a queued message: each dropped one comes back
+// with a "Run it" button (kept 24 h, core/turn-journal).
+function dropOffer(items) {
+  if (!items || !items.length) return {};
+  try {
+    const keyboard = require("./turn-journal").droppedKeyboard(items);
+    return keyboard ? { keyboard } : {};
+  } catch (_) { return {}; }
+}
+
 // "Dropped 2 queued: "reboot pe2", "and check the…"": what /stop dropped, a
 // few words of each message (the first few in full, then a count).
 function droppedNote(items, kind) {
@@ -1784,7 +1796,7 @@ register({
       const parts = [];
       if (stopped) parts.push(`Cancelled ${stopped} running conversation${stopped === 1 ? "" : "s"}.`);
       if (dropped.length) parts.push(droppedNote(dropped, stopped ? "queued" : "waiting"));
-      return send(parts.join(" "));
+      return send(parts.join(" "), dropOffer(dropped));
     }
     // /stop cancels the CURRENT conversation's turn only (other threads keep
     // running) and drops what was queued in it before the /stop: the person
@@ -1795,12 +1807,12 @@ register({
     const dropped = dropLaneQueue(lane, STOP_DROP_REASON);
     if (stopLane(state, lane)) {
       await sideCancellation;
-      await send(dropped.length ? `Cancelled. ${droppedNote(dropped, "queued")}` : "Cancelled.");
+      await send(dropped.length ? `Cancelled. ${droppedNote(dropped, "queued")}` : "Cancelled.", dropOffer(dropped));
     } else if (dropped.length) {
       // Nothing to cancel: the dropped messages were waiting for a slot (or
       // queued behind a turn that is only finishing its tail).
       await sideCancellation;
-      await send(droppedNote(dropped, laneBusy(lane) ? "queued" : "waiting"));
+      await send(droppedNote(dropped, laneBusy(lane) ? "queued" : "waiting"), dropOffer(dropped));
     } else if (await sideCancellation) await send("Cancelled side response.");
     else await send("Nothing running.");
   },

package/core/lessons.js

@@ -148,8 +148,15 @@ function listLessons() {
 // then most recently reinforced) survive the char budget. Returns "" when
 // there are none, so the system prompt stays clean on a fresh install.
 function loadLessonsBlock() {
+  const out = injectedLessons().map(lessonLine);
+  if (out.length === 0) return "";
+  return out.join("\n");
+}
+
+// The lessons the always-injected block carries, in its order, with meta.
+function injectedLessons() {
   const lessons = readLessons();
-  if (lessons.length === 0) return "";
+  if (lessons.length === 0) return [];
   const meta = reconcileMeta(lessons);
   const ranked = lessons.slice().sort((a, b) => {
     const ma = meta[a.id] || {}, mb = meta[b.id] || {};
@@ -162,11 +169,10 @@ function loadLessonsBlock() {
   for (const l of ranked) {
     const line = lessonLine(l);
     if (used + line.length + 1 > MAX_LESSONS_CHARS) break;
-    out.push(line);
+    out.push({ ...l, ...(meta[l.id] || {}) });
     used += line.length + 1;
   }
-  if (out.length === 0) return "";
-  return out.join("\n");
+  return out;
 }
 
 // Add or reinforce a lesson. Dedupe is by normalized text (id), so the same
@@ -271,7 +277,7 @@ module.exports = {
   LESSONS_FILE, LESSONS_META_FILE,
   MAX_LESSONS, MAX_LESSON_CHARS, MAX_LESSONS_CHARS,
   normalize, lessonId, parseLessons,
-  readLessons, listLessons, loadLessonsBlock,
+  readLessons, listLessons, loadLessonsBlock, injectedLessons, lessonLine,
   readMeta, writeMeta, reconcileMeta,
   addLesson, editLesson, removeLesson, saveLessonsRaw, lessonsExist,
 };

package/core/loopback.js

@@ -91,12 +91,14 @@ const OWNER_ONLY_KINDS = new Set([
   "people-list", "people-show", "people-note",
   "task-add", "task-plan", "task-update", "task-remove",
   "task-list", "task-get", "task-tree", "task-clear-completed",
+  "task-archive", "task-restore", "task-archived",
 ]);
 const JSON_KINDS = new Set([
   "whoami",
   "schedule-wakeup", "cron-add", "cron-remove", "job-list",
   "watch-add", "watch-list", "watch-remove", "watch-toggle",
   "task-add", "task-plan", "task-update", "task-remove", "task-list", "task-get", "task-tree", "task-clear-completed",
+  "task-archive", "task-restore", "task-archived",
   "people-list", "people-show", "people-add", "people-note", "people-link", "people-unlink",
   "people-remove", "people-set-primary",
   "intros-list", "intros-approve", "intros-reject",
@@ -668,9 +670,12 @@ async function handleJson(req, res, url, kind) {
   if (kind === "task-add") {
     if (!payload.content) return reply(res, 400, { error: "missing content" });
     try {
+      // A task belongs to the conversation it was made in (the run's thread,
+      // null on the main timeline); a subtask follows its plan.
       const t = tasksStore.add(adapterId, channelId, payload.content, {
         parentId: payload.parentId || null,
         description: payload.description || null,
+        threadId: threadForCaller(callerOf(payload), channelId, payload.threadId),
       });
       return reply(res, 200, { ok: true, task: t });
     } catch (e) { return reply(res, 400, { error: e.message }); }
@@ -682,6 +687,7 @@ async function handleJson(req, res, url, kind) {
     if (subs.length === 0) return reply(res, 400, { error: "subtasks must be a non-empty array" });
     const result = tasksStore.plan(adapterId, channelId, payload.title, subs, {
       description: payload.description || null,
+      threadId: threadForCaller(callerOf(payload), channelId, payload.threadId),
     });
     return reply(res, 200, { ok: true, plan: result });
   }
@@ -723,6 +729,29 @@ async function handleJson(req, res, url, kind) {
     return reply(res, got ? 200 : 404, { ok: !!got, ...(got || {}) });
   }
 
+  if (kind === "task-archive") {
+    if (!payload.id) return reply(res, 400, { error: "missing id" });
+    try {
+      const result = tasksStore.archive(adapterId, channelId, payload.id, payload.reason);
+      return reply(res, result ? 200 : 404, { ok: !!result, ...(result || {}) });
+    } catch (e) { return reply(res, 400, { error: e.message }); }
+  }
+
+  if (kind === "task-restore") {
+    if (!payload.id) return reply(res, 400, { error: "missing id" });
+    try {
+      const result = tasksStore.restore(adapterId, channelId, payload.id);
+      return reply(res, result ? 200 : 404, { ok: !!result, ...(result || {}) });
+    } catch (e) { return reply(res, 400, { error: e.message }); }
+  }
+
+  if (kind === "task-archived") {
+    const limit = Number(payload.limit);
+    const opts = { search: payload.search || "" };
+    if (Number.isFinite(limit) && limit > 0) opts.limit = limit;
+    return reply(res, 200, { ok: true, tasks: tasksStore.archived(adapterId, channelId, opts) });
+  }
+
   if (kind === "task-clear-completed") {
     const remaining = tasksStore.clearCompleted(adapterId, channelId);
     return reply(res, 200, { ok: true, tasks: remaining });

package/core/providers/claude-events.js

@@ -58,6 +58,15 @@ function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
   const decoderFailure = normalizeDecoderError(rawEvent);
   if (decoderFailure) return [decoderFailure];
 
+  // A helper agent's (Agent/Task tool) own messages carry parent_tool_use_id:
+  // its working notes, tool calls and refusals are not this turn's reply.
+  // Only its spend still counts.
+  if (rawEvent.parent_tool_use_id && ["assistant", "stream_event", "user"].includes(rawEvent.type)) {
+    if (rawEvent.type !== "assistant") return [];
+    const usage = normalizedUsage(rawEvent.message?.usage, "provider_call", state.seenUsage);
+    return usage ? [usage] : [];
+  }
+
   if (rawEvent.type === "system" && rawEvent.subtype === "init") {
     const event = sessionEvent(rawEvent.session_id, state);
     return event ? [event] : [];

package/core/providers/codex.js

@@ -75,6 +75,52 @@ function imagePathsOf(context) {
   return paths;
 }
 
+// Codex hands --output-schema to OpenAI in strict mode, which refuses the call
+// (400 invalid_json_schema) when the root is not an object, or an object has no
+// properties, allows extra keys or leaves a property out of `required`
+// (6 Oct 2026: every passive-reply check, pack review, dedup and dream on Codex
+// bots failed that way). An object whose properties are all required is closed
+// with additionalProperties: false, which costs a reply nothing. A schema that
+// needs optional or free-form fields gives null: no schema is sent, and the
+// utility agent still checks the reply against the caller's full schema.
+function strictOutputSchema(schema) {
+  function close(node, depth) {
+    if (!node || typeof node !== "object" || Array.isArray(node)) return depth > 0 ? node : null;
+    if (depth > 20 || node.$ref !== undefined) return null;
+    const copy = { ...node };
+    if ([].concat(node.type || []).includes("object")) {
+      const properties = node.properties && typeof node.properties === "object" ? node.properties : {};
+      const keys = Object.keys(properties);
+      if (!keys.length) return null;
+      if (node.additionalProperties && typeof node.additionalProperties === "object") return null;
+      const required = new Set(Array.isArray(node.required) ? node.required : []);
+      if (keys.some((key) => !required.has(key))) return null;
+      copy.properties = {};
+      for (const key of keys) {
+        const child = close(properties[key], depth + 1);
+        if (child === null) return null;
+        copy.properties[key] = child;
+      }
+      copy.additionalProperties = false;
+    }
+    if (node.items !== undefined) {
+      const items = Array.isArray(node.items) ? null : close(node.items, depth + 1);
+      if (items === null) return null;
+      copy.items = items;
+    }
+    for (const key of ["anyOf", "oneOf", "allOf"]) {
+      if (node[key] === undefined) continue;
+      if (!Array.isArray(node[key])) return null;
+      const variants = node[key].map((variant) => close(variant, depth + 1));
+      if (variants.includes(null)) return null;
+      copy[key] = variants;
+    }
+    return copy;
+  }
+  if (!schema || typeof schema !== "object" || schema.type !== "object") return null;
+  return close(schema, 0);
+}
+
 function createCodexProvider(options = {}) {
   const resolveExecutable = options.resolveExecutable || (() => config.discoverProviderExecutable("codex"));
   const defaultModel = options.defaultModel ?? config.config.CODEX_MODEL ?? null;
@@ -266,6 +312,7 @@ function createCodexProvider(options = {}) {
       return buildInvocation({ ...context, permissionMode: "plan" }, false);
     },
     buildUtilityInvocation: (context) => buildInvocation({ ...context, fresh: true }, true),
+    outputSchemaFor: (schema) => strictOutputSchema(schema),
     createEventDecoder: (decoderOptions) => createJsonlDecoder(decoderOptions),
     normalizeEvent: normalizeCodexEvent,
     authStatus: () => getAuthStatus(executable()),
@@ -300,4 +347,5 @@ module.exports = {
   capabilities,
   codexProvider,
   createCodexProvider,
+  strictOutputSchema,
 };

package/core/relationship.js

@@ -323,4 +323,4 @@ function ensureContact(envelope) {
   }
 }
 
-module.exports = { speakerFor, currentSpeaker, guardActive, isCurrentSpeakerGuarded, ownerTarget, ownerTargets, configuredOwnerTarget, ensureContact };
+module.exports = { speakerFor, currentSpeaker, guardActive, isCurrentSpeakerGuarded, ownerTarget, ownerTargets, configuredOwnerTarget, ensureContact, resolveHandleSendTarget };

package/core/router.js

@@ -431,8 +431,13 @@ async function handleDocument(envelope) {
       attachments: [{ type: "document", mimeType: media.mimeType || null, fileName: media.fileName || null }],
     });
     stopPreTurnTyping = startPreTurnTyping(state);
+    // Saved before the guard runs: a held request resumes after the owner's
+    // approval from the guard's text alone (core/actions.js), so that text
+    // must say where the file is. The adapters keep the file inside FILES_DIR
+    // under a cleaned name (core/safe-filename.js), and that name is the one
+    // shown, never the sender's raw path.
     const savePath = await envelope.adapter.downloadMedia(media);
-    const fileName = media.fileName || path.basename(savePath);
+    const fileName = path.basename(savePath);
     const mime = media.mimeType || "";
     const caption = envelope.caption || "";
     const isImage = mime.startsWith("image/");