@inetafrica/open-claudia 2.6.23 → 2.6.25

package/bin/cli.js

@@ -335,7 +335,7 @@ Memory tools:
                                              (alias: ts; --all for every project; --help for options)
   open-claudia transcript-window <pattern>   Search project transcript, show hits with context
                                              (alias: tw; --help for options)
-  open-claudia pack list|show|match|migrate  Context packs: living topic docs (skills + memory)
+  open-claudia pack list|show|match|archive|restore|archived  Context packs: living topic docs (skills + memory)
   open-claudia entity list|show|match|note   Entity notes: people/places/projects memory
   open-claudia dream [--dry-run]             Run the memory consolidation pass now
 

package/bin/pack.js

@@ -19,9 +19,36 @@ function run(args) {
       const all = packs.listPacks();
       if (all.length === 0) return console.log(`No packs yet (${packs.PACKS_DIR}).`);
       for (const p of all) {
-        const used = p.last_used ? ` last-used ${p.last_used.slice(0, 10)}` : "";
+        const used = p.last_used ? ` last-used ${p.last_used.slice(0, 10)} (${p.usage_count || 0}×)` : "";
         console.log(`${p.dir} — ${p.name}${p.tags.length ? ` [${p.tags.join(", ")}]` : ""}${used}\n    ${p.description}`);
       }
+      const archived = packs.listArchived();
+      if (archived.length) console.log(`\n(${archived.length} archived — open-claudia pack archived)`);
+      break;
+    }
+
+    case "archive": {
+      const p = packs.archivePack(rest[0]);
+      if (!p) { console.error(`No pack: ${rest[0]}`); process.exitCode = 1; return; }
+      console.log(`Archived pack ${p.dir} → ${path.join(packs.PACKS_DIR, ".archived", p.dir)}\nRestore with: open-claudia pack restore ${p.dir}`);
+      break;
+    }
+
+    case "restore": {
+      let p;
+      try { p = packs.restorePack(rest[0]); }
+      catch (e) { console.error(e.message); process.exitCode = 1; return; }
+      if (!p) { console.error(`No archived pack: ${rest[0]}`); process.exitCode = 1; return; }
+      console.log(`Restored pack ${p.dir}.`);
+      break;
+    }
+
+    case "archived": {
+      const all = packs.listArchived();
+      if (all.length === 0) return console.log("No archived packs.");
+      for (const p of all) {
+        console.log(`${p.dir} — ${p.name}  (archived ${(p.archived || "").slice(0, 10)}, last-used ${(p.last_used || "never").slice(0, 10)}, ${p.usage_count || 0}×)`);
+      }
       break;
     }
 
@@ -29,6 +56,9 @@ function run(args) {
       const p = packs.findPack(rest[0]);
       if (!p) { console.error(`No pack: ${rest[0]}`); process.exitCode = 1; return; }
       console.log(fs.readFileSync(path.join(packs.PACKS_DIR, p.dir, "PACK.md"), "utf-8"));
+      const prov = packs.readProvenance(p.dir);
+      const authored = packs.SECTIONS.map((s) => `${s}=${prov.sections[s] || "user"}`).join("  ");
+      console.log(`\n# provenance: ${authored}${prov.lastWriter ? `  (last: ${prov.lastWriter} ${prov.ts})` : ""}`);
       break;
     }
 
@@ -93,7 +123,7 @@ function run(args) {
     }
 
     default:
-      console.log("Usage: open-claudia pack [list|show <dir>|match \"<text>\"|migrate|remove <dir>|reindex]");
+      console.log("Usage: open-claudia pack [list|show <dir>|match \"<text>\"|migrate|remove <dir>|archive <dir>|restore <dir>|archived|reindex]");
   }
 }
 

package/core/dream.js

@@ -14,6 +14,7 @@ const path = require("path");
 const cron = require("node-cron");
 
 const CONFIG_DIR = require("../config-dir");
+const { config } = require("./config");
 const packs = require("./packs");
 const entities = require("./entities");
 const persona = require("./persona");
@@ -23,7 +24,13 @@ const DREAM_MODEL = process.env.DREAM_MODEL || "sonnet";
 const DREAM_CRON = process.env.DREAM_CRON || "0 4 * * *";
 const MAX_PACK_CHARS = 2500;
 const MAX_ENTITY_CHARS = 900;
-const LIMITS = { merges: 3, umbrellas: 2, parents: 8, retag: 8, entity_merges: 3, entity_notes: 4 };
+const LIMITS = { merges: 3, umbrellas: 2, parents: 8, retag: 8, entity_merges: 3, entity_notes: 4, archive: 5 };
+
+// Retirement guard: even if the model proposes archiving, only act when a pack
+// is genuinely cold — old enough, idle long enough, and rarely used. Protects
+// freshly-created packs the user just made.
+const ARCHIVE_IDLE_DAYS = Number(process.env.DREAM_ARCHIVE_IDLE_DAYS || 30);
+const ARCHIVE_MAX_USAGE = Number(process.env.DREAM_ARCHIVE_MAX_USAGE || 3);
 
 let _dreaming = false;
 
@@ -31,6 +38,15 @@ function enabled() {
   return (process.env.DREAM || "on").toLowerCase() !== "off";
 }
 
+// Whether to post the post-dream summary into the owner's chat. On by
+// default; toggled with /dreamsummary (persisted to .env, read back from
+// config on restart, with the live process.env taking precedence so the
+// toggle takes effect without a restart).
+function summaryEnabled() {
+  const v = process.env.DREAM_SUMMARY ?? config.DREAM_SUMMARY ?? "on";
+  return String(v).toLowerCase() !== "off";
+}
+
 function clip(s, n) {
   const t = String(s || "");
   return t.length > n ? t.slice(0, n) + "\n…[truncated]" : t;
@@ -45,8 +61,8 @@ function buildDreamPrompt() {
     `name: ${p.name}`,
     `description: ${p.description}`,
     `tags: ${p.tags.join(", ")}`,
-    `last_used: ${p.last_used || "never"}`,
-    `Stance: ${p.sections.Stance}`,
+    `last_used: ${p.last_used || "never"} (used ${p.usage_count || 0}×)`,
+    `Stance${packs.provenanceOf(p.dir, "Stance") === "user" ? " (USER-AUTHORED — do not rewrite)" : ""}: ${p.sections.Stance}`,
     `Procedure: ${p.sections.Procedure}`,
     `State: ${p.sections.State}`,
     `Journal:\n${p.sections.Journal}`,
@@ -77,19 +93,20 @@ ${persona.loadPersona()}
 
 Your job — decide what consolidation, if any, is warranted:
 
-1. merges: packs that are clearly the SAME topic under different names get merged into one. Supply the merged Stance/Procedure/State (synthesised, not concatenated; null leaves the target's section alone) and a one-sentence journal note. Be conservative: when in doubt, do not merge.
+1. merges: packs that are clearly the SAME topic under different names get merged into one. Supply the merged Stance/Procedure/State (synthesised, not concatenated; null leaves the target's section alone) and a one-sentence journal note. Be conservative: when in doubt, do not merge. A Stance marked USER-AUTHORED is off-limits — leave its stance null; the system preserves it verbatim regardless.
 2. umbrellas: when 3+ packs are siblings under one theme, create an umbrella pack whose State is a 3-6 line map of the family ("for X see pack Y"), and list its children. The umbrella is a router, not a duplicate.
 3. parents: assign an existing pack as parent of another (sub-topic relationship) without creating anything.
 4. retag: tighten descriptions and tags. The router FTS-matches incoming messages against name/description/tags, so generic words there cause false matches. Descriptions should be one specific line; tags specific nouns.
 5. entity_merges: the same real-world entity recorded twice gets merged (the better slug wins).
 6. entity_notes: rewrite an entity's Notes to be current and cross-linked — mention related packs as [[pack-dir]] and related entities by name.
-7. persona: evolve the persona GENTLY — keep its structure and length (under 2200 chars), adjust only what recent work justifies (a new habit, a sharpened quirk). Most dreams should return null here.
-8. report: a short chat message to the owner, written AS Open Claudia in first person — warm, a little playful, a few emojis, mobile-friendly (2-6 short lines). Say what you tidied and why it helps. If you changed nothing, say the memory is in good shape, charmingly.
+7. archive: retire packs that have gone cold — long unused AND rarely used over their life (consult last_used and the usage count). Archiving moves a pack out of the live index (reversibly, backed up) so it stops adding recall noise. ONLY propose packs idle ≥${ARCHIVE_IDLE_DAYS} days and used ≤${ARCHIVE_MAX_USAGE}× total; never an umbrella/parent pack that still has children; when in doubt, leave it. Give a one-line reason.
+8. persona: evolve the persona GENTLY — keep its structure and length (under 2200 chars), adjust only what recent work justifies (a new habit, a sharpened quirk). Most dreams should return null here.
+9. report: a short chat message to the owner, written AS Open Claudia in first person — warm, a little playful, a few emojis, mobile-friendly (2-6 short lines). Say what you tidied and why it helps. If you changed nothing, say the memory is in good shape, charmingly.
 
 Hard rules:
 - Never invent packs/entities not listed above; reference them by exact dir/slug.
 - Never store secrets, tokens, passwords, or credentials anywhere.
-- Limits: ≤${LIMITS.merges} merges, ≤${LIMITS.umbrellas} umbrellas, ≤${LIMITS.parents} parents, ≤${LIMITS.retag} retags, ≤${LIMITS.entity_merges} entity merges, ≤${LIMITS.entity_notes} entity note rewrites.
+- Limits: ≤${LIMITS.merges} merges, ≤${LIMITS.umbrellas} umbrellas, ≤${LIMITS.parents} parents, ≤${LIMITS.retag} retags, ≤${LIMITS.entity_merges} entity merges, ≤${LIMITS.entity_notes} entity note rewrites, ≤${LIMITS.archive} archives.
 - An empty decision is a perfectly good decision.
 
 Reply with ONLY a JSON object, no prose, no code fences:
@@ -99,6 +116,7 @@ Reply with ONLY a JSON object, no prose, no code fences:
  "retag": [{"pack": "<dir>", "description": "<one specific line>", "tags": ["..."]}],
  "entity_merges": [{"into": "<slug>", "from": ["<slug>"], "notes": "<merged Notes or null>"}],
  "entity_notes": [{"entity": "<slug>", "notes": "<rewritten Notes>"}],
+ "archive": [{"pack": "<dir>", "reason": "<one line: why it's cold>"}],
  "persona": null,
  "report": "<chat message>"}`;
 }
@@ -118,6 +136,7 @@ function parseDream(text) {
       retag: arr("retag"),
       entity_merges: arr("entity_merges"),
       entity_notes: arr("entity_notes"),
+      archive: arr("archive"),
       persona: typeof obj.persona === "string" ? obj.persona : null,
       report: typeof obj.report === "string" ? obj.report.trim() : "",
     };
@@ -161,18 +180,19 @@ function applyDream(decision, backupRoot) {
       const into = m?.into && packs.readPack(m.into);
       const from = [].concat(m?.from || []).filter((d) => d && d !== m.into && !gone.has(d) && packs.readPack(d));
       if (!into || from.length === 0) continue;
-      packs.updatePack(m.into, {
+      const mr = packs.updatePack(m.into, {
         stance: typeof m.stance === "string" ? m.stance : "",
         procedure: typeof m.procedure === "string" ? m.procedure : "",
         state: typeof m.state === "string" ? m.state : "",
         journal: m.journal || `absorbed ${from.join(", ")}`,
-      });
+      }, "dream");
       for (const d of from) {
         backupPack(d, backupRoot);
         packs.removePack(d);
         gone.add(d);
       }
       lines.push(`📦 Merged ${from.join(" + ")} into ${m.into}`);
+      if (mr.protectedStance) lines.push(`🛡️ Kept ${m.into}'s user-authored Stance as-is`);
     } catch (e) { console.warn(`[dream] merge failed: ${e.message}`); }
   }
 
@@ -190,7 +210,7 @@ function applyDream(decision, backupRoot) {
           tags: Array.isArray(u.tags) ? u.tags.slice(0, 6) : [],
           state: u.state || "",
           journal: `umbrella created over ${children.join(", ")}`,
-        });
+        }, "dream");
       }
       for (const c of children) {
         const child = packs.readPack(c);
@@ -222,7 +242,7 @@ function applyDream(decision, backupRoot) {
       const desc = typeof r.description === "string" ? r.description.trim() : "";
       const tags = Array.isArray(r.tags) ? r.tags.map((t) => String(t).trim()).filter(Boolean).slice(0, 6) : [];
       if (!desc && tags.length === 0) continue;
-      packs.updatePack(r.pack, { description: desc, tags });
+      packs.updatePack(r.pack, { description: desc, tags }, "dream");
       lines.push(`🏷️ Sharpened ${r.pack}'s description/tags`);
     } catch (e) { console.warn(`[dream] retag failed: ${e.message}`); }
   }
@@ -259,6 +279,27 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] entity notes failed: ${e.message}`); }
   }
 
+  if (decision.archive && decision.archive.length) {
+    const allPacks = packs.listPacks();
+    for (const a of decision.archive) {
+      try {
+        const dir = a?.pack;
+        if (!dir || gone.has(dir)) continue;
+        const pack = packs.readPack(dir);
+        if (!pack) continue;
+        if (allPacks.some((p) => p.parent === dir)) continue; // never orphan children
+        const ageDays = pack.created ? (Date.now() - Date.parse(pack.created)) / 86400000 : Infinity;
+        const idleDays = pack.last_used ? (Date.now() - Date.parse(pack.last_used)) / 86400000 : ageDays;
+        const uses = Number(pack.usage_count) || 0;
+        if (ageDays < ARCHIVE_IDLE_DAYS || idleDays < ARCHIVE_IDLE_DAYS || uses > ARCHIVE_MAX_USAGE) continue;
+        backupPack(dir, backupRoot);
+        packs.archivePack(dir);
+        gone.add(dir);
+        lines.push(`🗃 Archived ${dir} — ${a.reason || `idle ${Math.round(idleDays)}d, used ${uses}×`}`);
+      } catch (e) { console.warn(`[dream] archive failed: ${e.message}`); }
+    }
+  }
+
   if (decision.persona) {
     try {
       if (persona.personaExists()) {
@@ -305,8 +346,9 @@ async function runDream({ trigger = "manual" } = {}) {
 }
 
 // In-bot scheduler: one quiet-hours cron, reporting to the owner's
-// Telegram chat. Silent (console only) when the dream changed nothing —
-// a nightly "all tidy" ping would be noise.
+// 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)) {
@@ -318,7 +360,8 @@ function initDream(adapters) {
       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 (res.applied.length === 0) return;
+      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);
@@ -329,4 +372,4 @@ function initDream(adapters) {
   console.log(`dream: scheduled (${DREAM_CRON}, model ${DREAM_MODEL})`);
 }
 
-module.exports = { runDream, initDream, buildDreamPrompt, parseDream, applyDream, enabled, DREAM_CRON, DREAM_MODEL };
+module.exports = { runDream, initDream, buildDreamPrompt, parseDream, applyDream, enabled, summaryEnabled, DREAM_CRON, DREAM_MODEL };

package/core/handlers.js

@@ -125,7 +125,7 @@ register({
       "Settings: /model /effort /budget /plan /compact /compactwindow /worktree /mode",
       "Identity: /whoami /link",
       "Team: /people /intros /auth (owner)",
-      "Automation: /cron /vault /soul",
+      "Automation: /cron /vault /soul /dreamsummary",
       "Claude auth: /auth_status /login /setup_token /use_oauth_token /clear_oauth_token",
       "Codex auth: /codex_auth_status /codex_login /codex_setup_token",
       "System: /doctor /requirements /restart /upgrade",
@@ -947,6 +947,24 @@ register({
   },
 });
 
+register({
+  name: "dreamsummary", description: "Toggle the post-dream memory summary in chat", args: "[on|off]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    const dream = require("./dream");
+    const arg = (tail || "").trim().toLowerCase();
+    if (arg !== "on" && arg !== "off") {
+      const on = dream.summaryEnabled();
+      return send(`Dream summary is ${on ? "on" : "off"}.\n\nAfter each nightly memory consolidation I ${on ? "post a short summary here" : "tidy up silently"}.\n\nToggle: /dreamsummary on · /dreamsummary off`);
+    }
+    saveEnvKey("DREAM_SUMMARY", arg);
+    process.env.DREAM_SUMMARY = arg;
+    return send(arg === "on"
+      ? "Dream summary on — I'll drop a short note here after each nightly memory tidy-up. 💤"
+      : "Dream summary off — I'll consolidate memory silently. Backups are still kept, so nothing is lost.");
+  },
+});
+
 // ── Learned skills (now backed by context packs) ────────────────────
 // Skills migrated into context packs (~/.open-claudia/packs). /skills is a
 // thin window onto that store; any stragglers still in the legacy
@@ -984,6 +1002,10 @@ register({
     }
     const lines = packs.map((p) => `• ${p.dir} — ${p.description || p.name || "(no description)"}`);
     let msg = `Skills / context packs (${packs.length}):\n\n${lines.join("\n")}`;
+    const archived = packsLib.listArchived();
+    if (archived.length) {
+      msg += `\n\n${archived.length} archived (cold packs retired by the nightly dream) — open-claudia pack archived to view, pack restore <dir> to bring one back.`;
+    }
     if (legacy.length) {
       msg += `\n\n${legacy.length} legacy skill(s) still in ~/.claude/skills — run open-claudia pack migrate to fold them in.`;
     }

package/core/pack-review.js

@@ -129,18 +129,18 @@ function applyAction(a) {
   if (a.action === "update" && a.pack) {
     const existing = packs.readPack(a.pack);
     if (!existing) return null;
-    packs.updatePack(a.pack, {
+    const r = packs.updatePack(a.pack, {
       journal: a.journal || "",
       state: typeof a.state === "string" ? a.state : "",
       stance: typeof a.stance === "string" ? a.stance : "",
       procedure: typeof a.procedure === "string" ? a.procedure : "",
-    });
-    return { kind: "update", dir: a.pack, name: existing.name, note: a.journal || "state updated" };
+    }, "reviewer");
+    return { kind: "update", dir: a.pack, name: existing.name, note: a.journal || "state updated", protectedStance: !!r.protectedStance };
   }
   if (a.action === "create" && (a.dir || a.name)) {
     const dir = packs.slugify(a.dir || a.name);
     if (packs.readPack(dir)) {
-      packs.updatePack(dir, { journal: a.journal || "", state: a.state || "" });
+      packs.updatePack(dir, { journal: a.journal || "", state: a.state || "" }, "reviewer");
       return { kind: "update", dir, name: a.name || dir, note: a.journal || "state updated" };
     }
     const pack = packs.createPack({
@@ -152,7 +152,7 @@ function applyAction(a) {
       procedure: a.procedure || "",
       state: a.state || "",
       journal: a.journal || "",
-    });
+    }, "reviewer");
     return { kind: "create", dir: pack.dir, name: pack.name, note: a.description || "" };
   }
   return null;

package/core/packs.js

@@ -70,8 +70,10 @@ function serialize(pack) {
     `created: ${pack.created || new Date().toISOString()}`,
     `updated: ${pack.updated || new Date().toISOString()}`,
     `last_used: ${pack.last_used || ""}`,
-    "---",
+    `usage_count: ${pack.usage_count || 0}`,
   );
+  if (pack.archived) fmLines.push(`archived: ${pack.archived}`);
+  fmLines.push("---");
   const sections = SECTIONS
     .map((s) => `## ${s}\n\n${(pack.sections?.[s] || "").trim()}`)
     .join("\n\n");
@@ -99,6 +101,8 @@ function readPack(dir) {
     created: fm.created || "",
     updated: fm.updated || (stat ? stat.mtime.toISOString() : ""),
     last_used: fm.last_used || "",
+    usage_count: Number(fm.usage_count || 0) || 0,
+    archived: fm.archived || "",
     sections,
   };
 }
@@ -133,7 +137,7 @@ function writePack(pack) {
   return pack.dir;
 }
 
-function createPack({ dir, name, description, tags, stance, procedure, state, journal, parent }) {
+function createPack({ dir, name, description, tags, stance, procedure, state, journal, parent }, origin = "user") {
   const d = slugify(dir || name);
   if (!d) throw new Error("pack needs a name");
   if (readPack(d)) throw new Error(`pack ${d} already exists`);
@@ -152,6 +156,7 @@ function createPack({ dir, name, description, tags, stance, procedure, state, jo
     },
   };
   writePack(pack);
+  setProvenance(d, SECTIONS.filter((s) => (pack.sections[s] || "").trim()), origin);
   return pack;
 }
 
@@ -159,23 +164,98 @@ function today() {
   return new Date().toISOString().slice(0, 10);
 }
 
+// ---------------------------------------------------------------------------
+// Provenance: a sidecar .provenance.json per pack records which origin
+// (user | reviewer | dream) last authored each section. Sections we never
+// explicitly stamped default to "user" — anything not proven to be automated
+// is protected as if you wrote it. This is what lets the reviewer and dream
+// rewrite their own output freely while never silently clobbering your words.
+function provFile(dir) {
+  return path.join(PACKS_DIR, dir, ".provenance.json");
+}
+
+function readProvenance(dir) {
+  let data = {};
+  try { data = JSON.parse(fs.readFileSync(provFile(dir), "utf-8")) || {}; } catch (e) {}
+  const sections = data.sections && typeof data.sections === "object" ? data.sections : {};
+  return { sections, lastWriter: data.lastWriter || "", ts: data.ts || "" };
+}
+
+function provenanceOf(dir, section) {
+  return readProvenance(dir).sections[section] || "user";
+}
+
+function setProvenance(dir, sectionNames, origin) {
+  if (!origin) return;
+  const names = [].concat(sectionNames || []).filter(Boolean);
+  if (!names.length) return;
+  const cur = readProvenance(dir);
+  for (const n of names) cur.sections[n] = origin;
+  cur.lastWriter = origin;
+  cur.ts = new Date().toISOString();
+  try {
+    fs.mkdirSync(path.join(PACKS_DIR, dir), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(provFile(dir), JSON.stringify(cur, null, 2), { mode: 0o600 });
+  } catch (e) {}
+}
+
+// A foreground Write/Edit to a PACK.md is you (or me acting on what you told
+// me), so stamp the touched section(s) "user" — this also resets a section the
+// reviewer/dream previously claimed back to user-authored once you edit it.
+function recordForegroundWrite(dir, { tool, oldString, content } = {}) {
+  try {
+    if (tool === "Write" && typeof content === "string") {
+      const { body } = parseFrontmatter(content);
+      const { sections } = parseSections(body);
+      const applied = SECTIONS.filter((s) => sections[s] && sections[s].trim());
+      setProvenance(dir, applied.length ? applied : SECTIONS, "user");
+      return;
+    }
+    if (tool === "Edit" && typeof oldString === "string" && oldString) {
+      const cur = fs.readFileSync(packFile(dir), "utf-8");
+      const idx = cur.indexOf(oldString);
+      if (idx < 0) { setProvenance(dir, SECTIONS, "user"); return; }
+      let found = null;
+      for (const s of SECTIONS) {
+        const h = cur.indexOf(`## ${s}`);
+        if (h >= 0 && h <= idx && (found === null || h > found.pos)) found = { sec: s, pos: h };
+      }
+      setProvenance(dir, found ? [found.sec] : SECTIONS, "user");
+    }
+  } catch (e) {}
+}
+
 // Apply a reviewer mutation. Only supplied fields change; journal entries
 // append (capped); state replaces (it represents "current truth").
-function updatePack(dir, { description, tags, stance, procedure, state, journal } = {}) {
+function updatePack(dir, { description, tags, stance, procedure, state, journal } = {}, origin = "user") {
   const pack = readPack(dir);
   if (!pack) throw new Error(`no pack: ${dir}`);
   pack.updated = new Date().toISOString();
   if (description) pack.description = description;
   if (Array.isArray(tags) && tags.length) pack.tags = tags;
-  if (typeof stance === "string" && stance.trim()) pack.sections.Stance = stance.trim();
-  if (typeof procedure === "string" && procedure.trim()) pack.sections.Procedure = procedure.trim();
-  if (typeof state === "string" && state.trim()) pack.sections.State = state.trim();
+  const applied = [];
+  let protectedStance = false;
+  if (typeof stance === "string" && stance.trim()) {
+    // Stance shapes behaviour, so a user-authored Stance is never silently
+    // overwritten by an automated writer — your intent wins.
+    if (origin !== "user" && provenanceOf(dir, "Stance") === "user") {
+      protectedStance = true;
+    } else {
+      pack.sections.Stance = stance.trim();
+      applied.push("Stance");
+    }
+  }
+  if (typeof procedure === "string" && procedure.trim()) { pack.sections.Procedure = procedure.trim(); applied.push("Procedure"); }
+  if (typeof state === "string" && state.trim()) { pack.sections.State = state.trim(); applied.push("State"); }
   if (typeof journal === "string" && journal.trim()) {
     const entries = pack.sections.Journal.split("\n").filter((l) => l.trim());
     entries.push(`- [${today()}] ${journal.trim().replace(/\n+/g, " ")}`);
     pack.sections.Journal = entries.slice(-MAX_JOURNAL_ENTRIES).join("\n");
+    applied.push("Journal");
   }
   writePack(pack);
+  if (applied.length) setProvenance(dir, applied, origin);
+  pack.protectedStance = protectedStance;
   return pack;
 }
 
@@ -193,10 +273,68 @@ function touchUsed(dirs) {
     const pack = readPack(dir);
     if (!pack) continue;
     pack.last_used = now;
+    pack.usage_count = (Number(pack.usage_count) || 0) + 1;
     try { writePack(pack); } catch (e) {}
   }
 }
 
+// ---------------------------------------------------------------------------
+// Lifecycle: archive stale packs to PACKS_DIR/.archived/<dir>. listPacks and
+// the FTS index skip dot-dirs, so an archived pack stops matching but the file
+// is kept and fully restorable. This is the brake on an index that only grows.
+
+const ARCHIVE_DIRNAME = ".archived";
+function archiveRoot() { return path.join(PACKS_DIR, ARCHIVE_DIRNAME); }
+
+function archivePack(nameOrDir) {
+  const pack = findPack(nameOrDir);
+  if (!pack) return null;
+  ensureDir();
+  fs.mkdirSync(archiveRoot(), { recursive: true, mode: 0o700 });
+  pack.archived = new Date().toISOString();
+  try { fs.writeFileSync(packFile(pack.dir), serialize(pack), { mode: 0o600 }); } catch (e) {}
+  const dest = path.join(archiveRoot(), pack.dir);
+  fs.rmSync(dest, { recursive: true, force: true });
+  fs.renameSync(path.join(PACKS_DIR, pack.dir), dest);
+  markIndexDirty();
+  return pack;
+}
+
+function listArchived() {
+  let entries;
+  try { entries = fs.readdirSync(archiveRoot()); } catch (e) { return []; }
+  const out = [];
+  for (const name of entries) {
+    if (name.startsWith(".")) continue;
+    let content;
+    try { content = fs.readFileSync(path.join(archiveRoot(), name, "PACK.md"), "utf-8"); }
+    catch (e) { continue; }
+    const { fm } = parseFrontmatter(content);
+    out.push({
+      dir: name,
+      name: fm.name || name,
+      description: fm.description || "",
+      last_used: fm.last_used || "",
+      usage_count: Number(fm.usage_count || 0) || 0,
+      archived: fm.archived || "",
+    });
+  }
+  return out.sort((a, b) => a.dir.localeCompare(b.dir));
+}
+
+function restorePack(nameOrDir) {
+  const needle = String(nameOrDir || "").trim().toLowerCase();
+  if (!needle) return null;
+  const found = listArchived().find((p) => p.dir.toLowerCase() === needle || p.name.toLowerCase() === needle);
+  if (!found) return null;
+  if (readPack(found.dir)) throw new Error(`an active pack ${found.dir} already exists`);
+  fs.renameSync(path.join(archiveRoot(), found.dir), path.join(PACKS_DIR, found.dir));
+  const pack = readPack(found.dir);
+  if (pack) { pack.archived = ""; pack.updated = new Date().toISOString(); try { writePack(pack); } catch (e) {} }
+  markIndexDirty();
+  return pack;
+}
+
 // Recognise a Write/Edit aimed at a pack file (for chat announcements).
 function packNameFromPath(filePath) {
   if (!filePath) return null;
@@ -333,4 +471,6 @@ module.exports = {
   PACKS_DIR, SECTIONS, slugify,
   listPacks, findPack, readPack, writePack, createPack, updatePack, removePack,
   touchUsed, packNameFromPath, matchPacks, reindex, markIndexDirty,
+  archivePack, restorePack, listArchived,
+  readProvenance, provenanceOf, setProvenance, recordForegroundWrite,
 };

package/core/runner.js

@@ -806,6 +806,13 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         if (packDir) {
           if (packsLib.readPack(packDir)) notifySkill(`pack:${packDir}`, `✏️ Updating my notes on ${packDir}…`);
           else notifySkill(`pack:${packDir}`, `📦 Starting a new pack: ${packDir} — open-claudia pack show ${packDir} to peek.`);
+          try {
+            packsLib.recordForegroundWrite(packDir, {
+              tool: toolName,
+              oldString: input?.old_string ?? input?.oldString,
+              content: input?.content,
+            });
+          } catch (e) {}
           return;
         }
         const entSlug = entitiesLib.entityNameFromPath(filePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.23",
+  "version": "2.6.25",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {