@inetafrica/open-claudia 3.0.25 → 3.0.27

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## v3.0.27 — Agency ledger, advisory "what's next", owner-guardrail capture, and a reboot that waits for the turn to end
+
+- **`/agenda` — one read-only work list across everything (Track B0).** A new aggregator normalises your persistent tasks, `spaces mine`, and connector inbox/notifications into a single list (source, title, status, due, staleness, blocked-on, last-touched). Pure visibility — it reads, it never acts. `/agency` is an alias.
+- **`/next` — the bot proposes what it would pick, and does nothing (Track B1, advisory).** A triage→rank→judge pipeline (deterministic prefilter → algorithmic rank → a small judge on the ambiguous top-N) says "here's what I'd do next and why." It acts on nothing without you — bounded autonomy (B2+) stays gated behind a shadow-mode review, exactly as planned.
+- **Owner-guardrail capture — say a rule mid-chat and it sticks (Track C0/C1).** When *you* say "from now on, always X" / "never Y" / "stop doing Z", a post-turn detector turns it into an always-loaded lesson immediately — no code change, no deploy. High-confidence phrasings are auto-captured with an announcement and a one-tap **Undo**; softer ones ask first (Save / No). Hard owner gate: a standing rule is **never** captured from an external speaker, and captured rules layer *above* lessons but can never override the code-fixed hard rules. Default-on; set `GUARDRAIL_CAPTURE=off` to disable.
+- **Always-on prompt budget — instrumented, not yet trimmed (Track X0).** Every real turn now measures the fixed always-on floor (soul, lessons, runtime state, slash list) versus the variable recall payload, recorded to telemetry so we can baseline cost before capping it. Pure measurement — the prompt itself is unchanged, so caching is unaffected. Exposed via `agency ledger` / `prompt-budget` CLIs and the recall stats.
+- **A reboot that never interrupts a turn.** The Telegram long-poll has a 10-minute wedge backstop that self-exits for a clean restart when polling is truly stuck. It now checks first whether any turn is running, queued, or compacting — and if so **defers** the exit, keeps attempting in-place recovery, and only restarts once the process is idle (all replies delivered). If polling self-heals meanwhile, no restart happens at all. Recovery only touches the poll socket, so an in-flight turn's subprocess and its outbound sends are untouched.
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds identically (FROM the pre-baked `:base`). Existing pods pick this up on their next approved upgrade. `GUARDRAIL_CAPTURE` is the one new (optional, default-on) env knob.
+
+## v3.0.26 — Spaces replies actually post (and stop saying "Queued.")
+
+- **An engaged Spaces reply no longer fails with 400 "Parent comment not found."** Core threads every agent reply under the triggering message id — a Telegram-ism. On Spaces that id is a *notification* id, not a comment id, so the backend rejected the whole post and the bot silently failed to answer any mention. `send()` now only threads under an explicit `comment:`-prefixed id and otherwise posts a top-level task comment; if a stale/deleted parent still 400s, it retries once at top level so the reply always lands.
+- **The bot threads its reply under the exact comment it's answering.** When a notification names a specific comment (a reply's `replyId`, or a mention/comment that targets a comment), the reply is threaded under it instead of floating at the task root. Task-level mentions and assignments stay top-level, as before.
+- **No more "Queued." noise on a task thread.** The transient queue/compaction acknowledgement is a chat-UX affordance for Telegram/Kazee. On a Spaces task it posted a throwaway "Queued." comment when a second turn stacked (and, pre-fix, that post itself 400'd). Spaces now stays silent while queued and simply posts the real reply when its turn runs. Per-identity run serialization is unchanged and intended — one being, one hand.
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds identically (FROM the pre-baked `:base`). Existing pods pick this up on their next approved upgrade.
+
 ## v3.0.25 — The bot types back on a Spaces task
 
 - **"Open Claudia is typing…" now shows on a Spaces task thread while the bot composes.** Core already runs a typing heartbeat around every agent turn (calling `adapter.typing()` every ~4s and `adapter.typingStop()` at turn-end); on Spaces those were no-op stubs. They now re-emit the exact `comment:typing` event a human client sends over the adapter's existing authenticated socket, so a teammate watching a task sees the bot compose like any other member — the same three-dot indicator the web and mobile apps already render.

package/bin/agency-ledger.js

@@ -0,0 +1,91 @@
+// open-claudia agency ledger [--json] [--source task|spaces|notification] [--limit N] [--no-spaces] [--ids]
+// open-claudia agency next   [--json] [--judge] [--no-record]   (advisory: what to do next)
+// open-claudia agenda    (alias for `agency ledger`)
+//
+// Read-only aggregated work list (Track B0) + advisory deliberation (Track B1):
+// persistent per-channel tasks + Spaces tasks assigned to me + connector inbox
+// notifications, normalized and ranked. `next` PROPOSES a single best action and
+// why — it acts on nothing.
+
+const path = require("path");
+const { context } = require("./loopback-client");
+
+const HELP = `
+Aggregated, read-only view of everything on your plate — plus an advisory pick.
+
+  open-claudia agenda [--json] [--source <s>] [--limit N] [--no-spaces] [--ids]
+  open-claudia agency ledger [ ... ]        (same as agenda)
+  open-claudia agency next [--json] [--judge] [--no-record]
+
+Ledger sources: persistent tasks (this channel) · Spaces tasks assigned to me ·
+connector notifications. Ranked overdue → due-soon → in-progress → recently-touched.
+
+  --json           machine-readable output
+  --source <s>     ledger filter: task | spaces | notification
+  --limit N        max rows per source (default 10)
+  --no-spaces      skip the Spaces fetch (local tasks + notifications only)
+  --ids            show entry ids
+
+next (advisory deliberation — proposes, never acts):
+  --judge          let a cheap model disambiguate a close top-N (default: deterministic)
+  --no-record      don't append to the shadow-mode log
+`;
+
+function takeFlag(args, name) {
+  const i = args.indexOf(`--${name}`);
+  if (i < 0) return null;
+  const v = args[i + 1];
+  args.splice(i, 2);
+  return v;
+}
+
+async function loadLedger(rest) {
+  const ledger = require(path.join(__dirname, "..", "core", "agency", "ledger"));
+  const ctx = context();
+  const result = await ledger.collect({
+    adapter: ctx.adapterId,
+    channelId: ctx.channelId,
+    includeSpaces: !rest.includes("--no-spaces"),
+  });
+  return { ledger, ctx, result };
+}
+
+async function runLedger(rest) {
+  const json = rest.includes("--json");
+  const showIds = rest.includes("--ids");
+  const source = takeFlag(rest, "source");
+  const limit = Number(takeFlag(rest, "limit")) || 10;
+
+  const { ledger, result } = await loadLedger(rest);
+  const out = source
+    ? { ...result, entries: (result.entries || []).filter((e) => e.source === source) }
+    : result;
+
+  if (json) { console.log(JSON.stringify(out, null, 2)); return; }
+  console.log(ledger.render(out, { now: result.generatedAt, limitPerSource: limit, showIds }));
+}
+
+async function runDeliberate(rest) {
+  const json = rest.includes("--json");
+  const useJudge = rest.includes("--judge");
+  const record = !rest.includes("--no-record");
+
+  const { ctx, result } = await loadLedger(rest);
+  const deliberate = require(path.join(__dirname, "..", "core", "agency", "deliberate"));
+  const proposal = await deliberate.deliberate(result, { now: result.generatedAt, useJudge });
+  if (record) {
+    try { deliberate.record(proposal, { channel: ctx.adapterId ? `${ctx.adapterId}:${ctx.channelId}` : null }); } catch (e) {}
+  }
+  if (json) { console.log(JSON.stringify(proposal, null, 2)); return; }
+  console.log(deliberate.render(proposal));
+}
+
+async function run(args) {
+  const sub = args[0];
+  if (sub === "--help" || sub === "help") { console.log(HELP); return; }
+  if (sub === "next" || sub === "deliberate") return runDeliberate(args.slice(1));
+  if (sub === "ledger") return runLedger(args.slice(1));
+  return runLedger(args.slice(0)); // `agenda` alias / bare flags
+}
+
+module.exports = { run, HELP };

package/bin/cli.js

@@ -365,6 +365,21 @@ switch (command) {
     require("./recall").run(args.slice(1));
     break;
   }
+  case "agency": {
+    Promise.resolve(require("./agency-ledger").run(args.slice(1)))
+      .catch((e) => { console.error(`agency command failed: ${e.message}`); process.exitCode = 1; });
+    break;
+  }
+  case "agenda": {
+    Promise.resolve(require("./agency-ledger").run(args.slice(1)))
+      .catch((e) => { console.error(`agenda command failed: ${e.message}`); process.exitCode = 1; });
+    break;
+  }
+  case "prompt-budget":
+  case "always-on": {
+    require("./prompt-budget").run(args.slice(1));
+    break;
+  }
 
   case "dream": {
     require("./dream").run(args.slice(1));

package/bin/prompt-budget.js

@@ -0,0 +1,49 @@
+// open-claudia prompt-budget [--json]
+//
+// Inspect the always-on prompt floor: the fixed token cost (soul + lessons +
+// runtime state + slash-command list + tool headlines + relationship/mandate)
+// carried on every turn, plus the variable recall payload. Baselines Track X of
+// the architecture plan so the floor can be capped as systems multiply.
+
+const path = require("path");
+
+const HELP = `
+Inspect the always-on prompt budget.
+
+  open-claudia prompt-budget [--json]     Rolling always-on floor + per-component breakdown
+
+Measured per real user turn into prompt-budget.jsonl with a rolling summary in
+prompt-budget-summary.json. Token counts are a local ~4-chars/token estimate —
+consistent for tracking growth, not an exact provider tokenization.
+`;
+
+function fmt(n) {
+  n = Math.round(n || 0);
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+}
+
+function run(args) {
+  const sub = args[0];
+  if (sub === "--help" || sub === "help") { console.log(HELP); process.exit(0); }
+  const budget = require(path.join(__dirname, "..", "core", "prompt-budget"));
+  const s = budget.summary();
+  if (args.includes("--json")) { console.log(JSON.stringify(s, null, 2)); return; }
+  console.log("Always-on prompt budget");
+  console.log("───────────────────────");
+  console.log(`Turns measured:      ${s.turns}`);
+  console.log(`Avg always-on:       ${fmt(s.avgAlwaysOnTokens)} tok`);
+  console.log(`Peak always-on:      ${fmt(s.maxAlwaysOnTokens)} tok`);
+  console.log(`Avg recall payload:  ${fmt(s.avgRecallTokens)} tok`);
+  console.log(`Avg total prompt:    ${fmt(s.avgTotalTokens)} tok`);
+  const comp = s.componentAvgTokens || {};
+  const rows = Object.entries(comp).sort((a, b) => b[1] - a[1]);
+  if (rows.length) {
+    console.log("");
+    console.log("Avg tokens by component (largest first):");
+    for (const [k, v] of rows) console.log(`  ${k.padEnd(16)} ${fmt(v)}`);
+  }
+  if (s.updatedAt) console.log(`\nUpdated:             ${s.updatedAt}`);
+  if (!s.turns) console.log("\n(no turns measured yet — populates after the next real user turn)");
+}
+
+module.exports = { run, HELP };

package/bin/recall.js

@@ -32,6 +32,12 @@ function stats(args) {
   console.log(`Nodes opened (📖):    ${s.opens}`);
   console.log(`Avg latency:         ${s.avgLatencyMs}ms`);
   console.log(`Cost:                $${s.costUsd}`);
+  try {
+    const budget = require(path.join(__dirname, "..", "core", "prompt-budget")).summary();
+    if (budget.turns) {
+      console.log(`Always-on floor:     ${budget.avgAlwaysOnTokens} tok avg (peak ${budget.maxAlwaysOnTokens}) — see \`open-claudia prompt-budget\``);
+    }
+  } catch (e) {}
   if (s.updatedAt) console.log(`Updated:             ${s.updatedAt}`);
 }
 

package/channels/spaces/adapter.js

@@ -202,9 +202,22 @@ class SpacesAdapter {
       actorName = actorName || `${actorId.firstName || ""} ${actorId.lastName || ""}`.trim() || actorId.email;
       actorId = actorId.id || actorId._id;
     }
+    // The specific comment to thread a reply under, when the event is about one:
+    // a reply → the reply comment (replyId); a comment/mention that targets a
+    // comment → that comment id. Absent for task-level mentions and assignments,
+    // where the reply is a top-level task comment.
+    const commentId = String(
+      data.replyId || inner.replyId
+      || data.commentId || inner.commentId
+      || (data.targetType === "comment" ? data.targetId : "")
+      || (inner.targetType === "comment" ? inner.targetId : "")
+      || (payload.targetType === "comment" ? payload.targetId : "")
+      || "",
+    );
     return {
       type,
       taskId,
+      commentId,
       actorId: actorId ? String(actorId) : "",
       actorName: actorName || "",
       spaceId: payload.spaceId || inner.spaceId || null,
@@ -261,7 +274,10 @@ class SpacesAdapter {
       userId: n.actorId || n.taskId,
       type: "text",
       text: n.content || `[${n.type} on task ${n.title || n.taskId}]`,
-      messageId: id,
+      // Thread the bot's reply under the exact comment that triggered this engage
+      // (a reply, or a mention targeting a comment). Falls back to the
+      // notification id, which send() posts as a top-level task comment.
+      messageId: n.commentId ? `comment:${n.commentId}` : id,
       from: { id: n.actorId, name: n.actorName },
       spaces: { taskId: n.taskId, spaceId: n.spaceId, notificationType: n.type, deepLink: n.deepLink, title: n.title, mode: this._taskLoopMode() },
       raw: payload,
@@ -473,15 +489,24 @@ class SpacesAdapter {
   async send(channelId, text, opts = {}) {
     const taskId = String(channelId || "").replace(/^task:/, "");
     if (!taskId) { console.error("Spaces send: no taskId in channelId", channelId); return null; }
+    // Thread only under an EXPLICIT comment id (a "comment:"-prefixed replyTo,
+    // set on an engaged reply/comment-mention). Core's default replyTo is the
+    // triggering NOTIFICATION id, which is not a comment — threading under it
+    // 400s ("Parent comment not found"), so treat anything else as a top-level
+    // task comment.
+    const replyTo = String(opts.replyTo || "");
+    const parentId = replyTo.startsWith("comment:") ? replyTo.slice("comment:".length) : null;
+    const post = (parent) => this.client.createComment({ taskId, text, mentions: opts.mentions || [], parentId: parent });
+    const idOf = (c) => (c && (c._id || c.id) ? String(c._id || c.id) : true);
     try {
-      const comment = await this.client.createComment({
-        taskId,
-        text,
-        mentions: opts.mentions || [],
-        parentId: opts.replyTo ? String(opts.replyTo).replace(/^comment:/, "") : null,
-      });
-      return comment && (comment._id || comment.id) ? String(comment._id || comment.id) : true;
+      return idOf(await post(parentId));
     } catch (e) {
+      // A stale/deleted parent 400s; retry once at top level so the reply always
+      // lands on the task rather than being dropped.
+      if (parentId && /parent comment not found/i.test(e.message || "")) {
+        try { return idOf(await post(null)); }
+        catch (e2) { console.error("Spaces send error (top-level retry):", e2.message); return null; }
+      }
       console.error("Spaces send error:", e.message);
       return null;
     }

package/channels/telegram/adapter.js

@@ -41,6 +41,7 @@ class TelegramAdapter {
     this._healTimer = null;      // one active recovery in flight at a time
     this._healthyTimer = null;   // fires once polling's been quiet long enough
     this._wedgedSince = 0;       // start of the current unrecovered error streak
+    this._deferredExitLogAt = 0; // throttle the "deferring restart, turn in progress" log (1/min)
     this._lastHiccupLog = 0;     // throttle the transient-error log (1/min)
     this._healBackoff = 0;       // grows per consecutive heal, capped
     this._pollWatchdogTimer = null; // detects a silent first/active getUpdates stall
@@ -139,6 +140,14 @@ class TelegramAdapter {
     await Promise.race([stopped, new Promise((r) => setTimeout(r, 5000))]);
   }
 
+  // Is ANY turn running/preparing/compacting/queued, for any user? The wedge-exit
+  // backstop consults this so a reboot never interrupts in-flight work. Isolated
+  // as a method (lazy require to dodge a load-time cycle) so tests can stub it.
+  _anyTurnActive() {
+    try { return require("../../core/state").anyTurnActive(); }
+    catch (e) { return false; }
+  }
+
   async _heal() {
     this._healTimer = null;
     // Backstop only: if polling has been unbroken-wedged for 10 minutes, a
@@ -149,9 +158,22 @@ class TelegramAdapter {
       // Never fires during a 409 streak: that's a token fight, not a network
       // wedge, and exiting busts the prompt cache (full uncached re-bill of the
       // conversation window on the next turn).
-      console.error("Polling wedged >10min — exiting for a clean restart.");
-      try { require("../../core/restart-reason").recordExitReason("Telegram polling wedged >10min (long-poll unrecoverable) — self-exit for a clean restart", { code: 1 }); } catch (e) {}
-      process.exit(1);
+      if (this._anyTurnActive()) {
+        // A turn is in flight — never reboot mid-turn: it kills in-progress work
+        // and breaks the seamless resume the user expects. Defer the exit, keep
+        // attempting in-place recovery below, and let a later heal exit once the
+        // process is idle. If polling self-heals meanwhile, the wedge clears and
+        // no exit ever happens. (Recovery only touches the poll socket — the
+        // running turn's subprocess and its outbound sends dial their own.)
+        if (!this._deferredExitLogAt || Date.now() - this._deferredExitLogAt > 60000) {
+          this._deferredExitLogAt = Date.now();
+          console.error("Polling wedged >10min but a turn is in progress — deferring restart until idle.");
+        }
+      } else {
+        console.error("Polling wedged >10min — exiting for a clean restart.");
+        try { require("../../core/restart-reason").recordExitReason("Telegram polling wedged >10min (long-poll unrecoverable) — self-exit for a clean restart", { code: 1 }); } catch (e) {}
+        process.exit(1);
+      }
     }
     try {
       await this._stopPollingClean("stale Telegram long-poll recovery");
@@ -169,6 +191,7 @@ class TelegramAdapter {
       if (this._wedgedSince) console.log("Polling healthy again.");
       this._wedgedSince = 0;
       this._healBackoff = 0;
+      this._deferredExitLogAt = 0;
     }, 30000);
   }
 

package/core/actions.js

@@ -513,6 +513,31 @@ async function handleAction(envelope) {
       : `⛔ Denied — ${label} will not run.`);
     return;
   }
+  if (d.startsWith("grd:")) {
+    // Guardrail capture buttons (Track C). Owner-only: standing rules layer
+    // above lessons and are never editable by an external speaker.
+    if (!isChatOwner(envelope.channelId)) return send("Owner only — standing rules are restricted.");
+    const guardrail = require("./guardrail");
+    const parts = d.split(":");
+    const verb = parts[1];
+    const arg = parts.slice(2).join(":");
+    if (verb === "save") {
+      const r = guardrail.confirmPending(arg);
+      if (!r.ok) return send("That rule prompt expired — say it again if you still want it kept.");
+      return send(r.added
+        ? `📌 Done — I'll keep "${String(r.text).slice(0, 160)}" loaded as a standing rule.`
+        : `📌 Already a standing rule — reinforced.`);
+    }
+    if (verb === "no") {
+      guardrail.dropPending(arg);
+      return send("Okay — not making that a standing rule.");
+    }
+    if (verb === "undo") {
+      const r = guardrail.undo(arg);
+      return send(r.ok ? "↩️ Undone — removed that standing rule." : "That rule was already gone.");
+    }
+    return;
+  }
   if (d.startsWith("tt:")) {
     state.settings.showToolTrace = d.slice(3) === "on";
     saveState();