@inetafrica/open-claudia 3.5.16 → 3.5.18

package/core/safe-filename.js

@@ -0,0 +1,47 @@
+"use strict";
+
+// Sender-chosen file names (Kazee and Telegram documents) become paths under
+// FILES_DIR. A name like "../auth.json" must never climb out of that folder,
+// yet "Invoice March (final).pdf" or "ripoti ya mauzo.xlsx" should stay as the
+// sender wrote them. Anything unusable falls back to the adapter's generated
+// name.
+
+const path = require("path");
+
+const MAX_BYTES = 200;   // well under the usual 255-byte filesystem limit
+const MAX_EXT_BYTES = 20;
+
+function capBytes(text, max) {
+  let out = "";
+  for (const ch of text) {
+    if (Buffer.byteLength(out + ch) > max) break;
+    out += ch;
+  }
+  return out;
+}
+
+// The cleaned name, or `fallback` when nothing safe is left.
+function safeFileName(name, fallback) {
+  let s = String(name ?? "").split(/[\\/]/).pop();
+  s = s.replace(/[\u0000-\u001f\u007f-\u009f]/g, "");
+  s = s.replace(/[^\p{L}\p{M}\p{N} ._\-()]/gu, "_").trim();
+  if (!s || s === "." || s === ".." || s.startsWith(".")) return fallback;
+  if (Buffer.byteLength(s) > MAX_BYTES) {
+    let ext = path.extname(s);
+    if (Buffer.byteLength(ext) > MAX_EXT_BYTES) ext = "";
+    s = capBytes(s.slice(0, s.length - ext.length), MAX_BYTES - Buffer.byteLength(ext)).trim() + ext;
+    if (!s || s.startsWith(".")) return fallback;
+  }
+  return s;
+}
+
+// baseDir joined with the cleaned name; the generated fallback whenever the
+// result would not sit directly inside baseDir.
+function safeJoin(baseDir, name, fallback) {
+  const root = path.resolve(baseDir);
+  const result = path.resolve(root, safeFileName(name, fallback));
+  if (!result.startsWith(root + path.sep) || path.dirname(result) !== root) return path.join(root, fallback);
+  return result;
+}
+
+module.exports = { safeFileName, safeJoin };

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");
@@ -31,6 +33,7 @@ const {
   getProjectKey,
   getProviderSession,
   getProviderSettings,
+  getProjectSessions,
   getUserState,
   peekLane,
   laneBusy,
@@ -186,6 +189,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 +223,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,
@@ -230,6 +248,7 @@ function createSchedulerService(dependencies = {}) {
     : dependencies.legacyCronsFile;
   const runInProvider = dependencies.runAgent || ((...args) => require("./runner").runAgent(...args));
   const admit = dependencies.admitRunContext || ((...args) => require("./runner").admitRunContext(...args));
+  const projectSessions = dependencies.getProjectSessions || getProjectSessions;
   const timers = new Map();
   const checksInFlight = new Set();
   const firesInFlight = new Set();
@@ -318,6 +337,26 @@ function createSchedulerService(dependencies = {}) {
     return getProviderSession(state, job.provider, roomKey) || null;
   }
 
+  // previous session -> the session it was compacted into, from the
+  // conversation's session history (each compaction's lineage is kept on the
+  // new session's record). The completed-compactions index holds only the
+  // last 20, under a day of token-diet compactions across every thread, so a
+  // job made before them lost its way: 7 Oct the PBX thread's wakeup and
+  // watch resumed a 790k conversation compacted that morning ($86).
+  function historySuccessors(state, job) {
+    const successors = new Map();
+    let records = [];
+    try { records = projectSessions(state?.userId || job.canonicalUserId, job.project, job.provider) || []; }
+    catch (_) { records = []; }
+    // Newest first: if a session was ever compacted twice, the latest wins.
+    for (const record of records) {
+      const lineage = record?.lineage;
+      if (lineage?.type !== "compaction" || !lineage.previousSessionId || !lineage.newSessionId) continue;
+      if (!successors.has(lineage.previousSessionId)) successors.set(lineage.previousSessionId, lineage.newSessionId);
+    }
+    return successors;
+  }
+
   function resolveCompactionLineage(state, job) {
     let sessionId = job.sessionId || null;
     // A thread job never resumes its room's MAIN session: a job made in a
@@ -330,6 +369,7 @@ function createSchedulerService(dependencies = {}) {
       sessionId = own && own !== mainSession ? own : null;
     }
     if (!sessionId) return { sessionId: null, attachSession: true };
+    let recorded = null;
     const seen = new Set();
     while (sessionId && !seen.has(sessionId)) {
       seen.add(sessionId);
@@ -338,9 +378,9 @@ function createSchedulerService(dependencies = {}) {
         && entry?.project === job.project
         && entry?.previousSessionId === sessionId
         && entry?.newSessionId
-      ));
+      ))?.newSessionId || (recorded ||= historySuccessors(state, job)).get(sessionId);
       if (!successor) break;
-      sessionId = successor.newSessionId;
+      sessionId = successor;
     }
     const live = getProviderSession(state, job.provider, job.project);
     return {
@@ -521,12 +561,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 +671,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 };
   }
 
@@ -581,6 +717,14 @@ function createSchedulerService(dependencies = {}) {
       lastProvider: target.provider,
       fallbackFromProvider: target.fallbackFrom,
     };
+    // A recurring job keeps its own conversation: remember the session this
+    // run resumed and ended on (lineage or a compaction may have moved it), so
+    // the next run starts there even after the lineage records age out. Only
+    // for a run that resumed the job's conversation under its own provider.
+    const ranOn = typeof result?.sessionId === "string" && result.sessionId ? result.sessionId : null;
+    if (!isOneShot(job) && ranOn && ranOn !== job.sessionId && target.sessionId && !target.fresh && target.provider === job.provider) {
+      successPatch.sessionId = ranOn;
+    }
     let marked;
     try { marked = jobsStore.update(job.id, successPatch); }
     catch (error) { return { ok: false, status: "failed", error: stableFailure(error), result }; }
@@ -722,32 +866,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 +957,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 +1055,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/state.js

@@ -1671,6 +1671,96 @@ function commitProviderCompaction(state, transaction, options = {}) {
   }
 }
 
+// A scheduled job resumes its own conversation: a branch beside its thread's
+// live session once the thread has moved on. Compacting that branch records
+// the lineage (on the new session's history record and in the completed-
+// compactions index) so the job moves on to the new session, but never
+// touches the thread's live pointer: the thread is not the job's conversation.
+function commitBranchCompaction(state, transaction, options = {}) {
+  const tx = validateCompactionTransaction(state, transaction);
+  if (state.completedCompactions?.[tx.operationId]) {
+    return {
+      committed: true,
+      duplicate: true,
+      operationId: tx.operationId,
+      sessionId: state.completedCompactions[tx.operationId].newSessionId,
+    };
+  }
+  if (getProviderSession(state, tx.provider, tx.project) === tx.previousSessionId) {
+    throw compactionError("COMPACTION_POINTER_CHANGED", "the branch became the live session before its compaction commit");
+  }
+  const persistState = options.persistState || saveState;
+  const recordHistory = options.recordHistory || recordSession;
+  const nowValue = typeof options.now === "function" ? options.now() : new Date();
+  const now = nowValue instanceof Date ? nowValue : new Date(nowValue);
+  if (!Number.isFinite(now.getTime())) throw compactionError("INVALID_COMPACTION", "compaction clock is invalid");
+  requireCompactionWrite(
+    recordHistory(
+      tx.canonicalUserId,
+      tx.project,
+      tx.provider,
+      tx.newSessionId,
+      tx.title || `Scheduled job conversation, compacted ${now.toLocaleDateString()}`,
+      {
+        strict: true,
+        now: () => now,
+        lineage: {
+          type: "compaction",
+          operationId: tx.operationId,
+          previousSessionId: tx.previousSessionId,
+          newSessionId: tx.newSessionId,
+          branch: true,
+        },
+      },
+    ),
+    "branch compaction history",
+  );
+  const newUsageKey = usageSessionKey(tx.project, tx.provider, tx.newSessionId);
+  if (!isRecord(state.usageBySession)) state.usageBySession = {};
+  const previousUsageBySession = state.usageBySession;
+  const previousCompleted = state.completedCompactions;
+  const nextUsage = {
+    ...freshUsage(),
+    lastCompactedAt: now.getTime(),
+    compactionCheckpoint: {
+      operationId: tx.operationId,
+      previousSessionId: tx.previousSessionId,
+      newSessionId: tx.newSessionId,
+      at: now.toISOString(),
+      branch: true,
+    },
+  };
+  if (tx.provider === "codex" && isRecord(tx.seedUsage)) {
+    nextUsage.providerUsageSnapshot = {
+      input_tokens: Number(tx.seedUsage.input_tokens) || 0,
+      cached_input_tokens: Number(tx.seedUsage.cached_input_tokens) || 0,
+      output_tokens: Number(tx.seedUsage.output_tokens) || 0,
+    };
+  }
+  state.usageBySession = boundUsageBySession({ ...previousUsageBySession, [newUsageKey]: nextUsage });
+  state.completedCompactions = Object.fromEntries(Object.entries({
+    ...cloneRecord(previousCompleted),
+    [tx.operationId]: {
+      project: tx.project,
+      provider: tx.provider,
+      previousSessionId: tx.previousSessionId,
+      newSessionId: tx.newSessionId,
+      committedAt: now.toISOString(),
+      branch: true,
+    },
+  }).slice(-20));
+  try {
+    requireCompactionWrite(persistState({ strict: true }), "branch compaction state");
+  } catch (error) {
+    // The history record stays: the new session IS the branch's compacted
+    // continuation, and the scheduler follows it from there.
+    state.usageBySession = previousUsageBySession;
+    state.completedCompactions = previousCompleted;
+    throw error;
+  }
+  return { committed: true, duplicate: false, branch: true, operationId: tx.operationId, sessionId: tx.newSessionId };
+}
+
 function migrateUserData(fromUserId, toUserId) {
   const from = normalizeCanonicalUserId(fromUserId);
   const to = normalizeCanonicalUserId(toUserId);
@@ -1828,6 +1918,7 @@ module.exports = {
   createSessionCallbackToken,
   consumeSessionCallbackToken,
   commitProviderCompaction,
+  commitBranchCompaction,
   recoverPendingCompaction,
   migrateUserData,
   linkIdentity,

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,