@inetafrica/open-claudia 3.0.17 → 3.0.18

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v3.0.18 — Spaces reconciles its task list (assigned tasks no longer silently missed)
+
+- **Assigning a task to the bot now actually engages it.** An assignment creates the task but emits **no notification**, and the conversational plane only woke on a socket "notification" push — so a task assigned to the bot could sit there while the bot never noticed (confirmed live: bot could `listTasks` its assigned task, but had 0 notifications and never engaged). The adapter now runs a self-contained **reconciliation poll**: on its own timer it calls `listTasks()` (bot-scoped to its assigned tasks) and synthesises a `task_assigned` engage for any active task it hasn't engaged yet.
+- **Robust to socket churn.** The Spaces socket transport reconnects constantly; a push emitted during a gap is lost with no replay. The timer also re-runs the existing notification catch-up `poll()` and, crucially, doesn't depend on the connected-apps poller (which can be disabled) — the Spaces plane drives itself. Cadence is `OC_SPACES_POLL_MS` (default 60s).
+- **Per-task engaged-dedup.** Engagement is now tracked per task (`markTaskEngaged`/`taskEngaged`), not per notification-id, so a task the socket already handled is skipped by reconcile and vice-versa — no double replies. Terminal (completed/archived/cancelled) tasks are skipped.
+- **A successful `listTasks()` is a connection signal** (`markRestConnected`) — the third leg of the hybrid auto-enable, independent of the flaky socket. `/spaces status` now shows a "Last poll" line. Still owner-gated: `/spaces pause` stops replies; reconcile records connection but engages nothing while paused/off.
+- **Agent-space / OpenClaw:** no new deps, no new required env (one optional `OC_SPACES_POLL_MS`), no schema change; Docker image builds identically (FROM the pre-baked `:base`). Existing pods pick this up on their next approved upgrade.
+
 ## v3.0.17 — Spaces auto-enables on connection; control moves into chat
 
 - **The Spaces conversational plane no longer hides behind an env flag.** `OC_SPACES_CONVERSATIONAL` is gone. Auto-replies now enable themselves the moment the bot is **connected** to Spaces, on a hybrid signal: central authoritatively lists Spaces among the bot's connected apps, **or** the socket has actually received a Spaces notification (which only happens for a task the bot is a member of). Either one flips it on — so it works today over the socket even before the central `/api/principal/applications` endpoint is deployed. It stays self-gating: no Spaces membership ⇒ no notifications ⇒ no replies.

package/channels/spaces/adapter.js

@@ -25,7 +25,7 @@ const spacesState = require("./state");
 const ENGAGE_TYPES = new Set(["mention", "reply", "task_assigned"]);
 
 class SpacesAdapter {
-  constructor({ id = "spaces", url = "https://api.spaces.kazee.africa", token, ownerUserId = "", taskLoopMode = "advisory" }) {
+  constructor({ id = "spaces", url = "https://api.spaces.kazee.africa", token, ownerUserId = "", taskLoopMode = "advisory", pollMs }) {
     this.id = id;
     this.type = "spaces";
     this.url = url.replace(/\/$/, "");
@@ -33,11 +33,17 @@ class SpacesAdapter {
     this.ownerUserId = ownerUserId || "";
     // Env default posture; the live value is chat-overridable via spacesState.
     this.taskLoopModeDefault = taskLoopMode || "advisory";
+    // Self-driving reconciliation cadence. The connected-apps poller used to be
+    // the only thing calling poll(); it can be disabled, so the adapter drives
+    // its own timer and never depends on it.
+    this.pollMs = Number(pollMs) > 0 ? Number(pollMs) : 60000;
     this.client = new SpacesClient({ baseUrl: this.url, token });
     this._listeners = { message: new Set(), action: new Set() };
     this._socket = null;
     this._seen = new Set(); // notification-id dedup across socket + poll
     this._taskChains = new Map(); // taskId -> tail promise, for per-task serialization
+    this._pollTimer = null;
+    this._initTimer = null;
   }
 
   on(event, fn) {
@@ -62,15 +68,32 @@ class SpacesAdapter {
       onDisconnect: (reason) => console.log(`Spaces socket disconnected: ${reason}`),
       onError: (err) => console.error("Spaces socket error:", err.message),
     });
+    // Self-contained catch-up loop: reconcile assigned tasks (which emit no
+    // notification) and replay any unread notifications the socket missed during
+    // a reconnect gap. Runs regardless of the connected-apps poller. unref so it
+    // never holds the process open on its own.
+    const tick = () => { this._tick(); };
+    this._pollTimer = setInterval(tick, this.pollMs);
+    if (this._pollTimer.unref) this._pollTimer.unref();
+    // Give the socket a moment to settle, then do an immediate first pass.
+    this._initTimer = setTimeout(tick, 3000);
+    if (this._initTimer.unref) this._initTimer.unref();
   }
 
   async stop() {
     try { this._socket?.disconnect?.(); } catch (e) {}
     this._socket = null;
+    if (this._pollTimer) { clearInterval(this._pollTimer); this._pollTimer = null; }
+    if (this._initTimer) { clearTimeout(this._initTimer); this._initTimer = null; }
   }
 
-  // REST catch-up. The connected-apps poller calls this on its cadence so a
-  // missed socket push (reconnect gap) still surfaces. Read-only.
+  async _tick() {
+    await this.reconcile();
+    await this.poll();
+  }
+
+  // REST catch-up for NOTIFICATION-bearing events (mentions, replies) the socket
+  // missed during a reconnect gap. Read-only.
   async poll() {
     try {
       const notifications = await this.client.listNotifications({ limit: 40, unreadOnly: true });
@@ -81,6 +104,53 @@ class SpacesAdapter {
     }
   }
 
+  // Reconcile against the task list. Assigning a task to the bot creates the task
+  // but emits NO notification, so poll() (notification-based) can never see it —
+  // this is why an assigned task silently failed to engage. listTasks() on the
+  // bot's own token returns exactly the tasks assigned to it, so we synthesise a
+  // task_assigned event for any active task we haven't engaged yet. Per-task
+  // engaged-dedup (not notification-id) means a task the socket already handled
+  // is skipped here. Read-only; the only write is the eventual reply, gated as
+  // usual. Success is also membership proof independent of the flaky socket.
+  async reconcile() {
+    let tasks;
+    try {
+      tasks = await this.client.listTasks();
+    } catch (e) {
+      console.error("Spaces reconcile error:", e.message);
+      return;
+    }
+    if (!Array.isArray(tasks)) return;
+    // Being able to list our own tasks proves we're connected — the REST leg of
+    // the hybrid signal, which survives socket churn.
+    try { spacesState.markRestConnected(); } catch (e) {}
+
+    let active = false;
+    try { active = spacesState.conversationalActive(); } catch (e) {}
+    if (!active) return; // connection recorded; engagement stays gated (paused/off)
+
+    const TERMINAL = new Set(["completed", "archived", "cancelled", "done"]);
+    for (const task of tasks) {
+      const taskId = String(task.id || task._id || "");
+      if (!taskId || task.isArchived) continue;
+      if (TERMINAL.has(String(task.status || "").toLowerCase())) continue;
+      try { if (spacesState.taskEngaged(taskId)) continue; } catch (e) {}
+      const spaceId = task.spaceId && typeof task.spaceId === "object"
+        ? (task.spaceId.id || task.spaceId._id || null)
+        : (task.spaceId || null);
+      const synthetic = {
+        id: `recon:${taskId}`,
+        type: "task_assigned",
+        targetType: "task",
+        targetId: taskId,
+        title: task.title || "",
+        spaceId,
+        actorId: task.creatorId || "",
+      };
+      this._handleNotification(synthetic, "reconcile");
+    }
+  }
+
   _notificationId(payload) {
     return String(payload?.id || payload?._id || "");
   }
@@ -174,6 +244,9 @@ class SpacesAdapter {
       spaces: { taskId: n.taskId, spaceId: n.spaceId, notificationType: n.type, deepLink: n.deepLink, title: n.title, mode: this._taskLoopMode() },
       raw: payload,
     };
+    // Record the engagement so the reconciliation poll won't re-synthesise an
+    // assignment for a task the socket/poll already handled (per-task dedup).
+    try { spacesState.markTaskEngaged(n.taskId); } catch (e) {}
     // Per-task serialization: a task's turns run one at a time so two comments
     // on the same task can't spawn concurrent, conflicting agent runs. Other
     // tasks proceed in parallel.

package/channels/spaces/state.js

@@ -35,6 +35,11 @@ function load() {
       centralAt: rawConn.centralAt || 0,
       socketFirstAt: rawConn.socketFirstAt || 0,
       socketLastAt: rawConn.socketLastAt || 0,
+      // REST reconciliation proof: a successful listTasks() means the bot can
+      // read its own Spaces tasks, which is membership proof independent of the
+      // socket (whose transport churns). Third leg of the hybrid signal.
+      restFirstAt: rawConn.restFirstAt || 0,
+      restLastAt: rawConn.restLastAt || 0,
     },
     // Owner control, set from chat (/spaces …) — never from env/filesystem, which
     // the owner can't reach on a pod. `muted` is the off-switch for auto-replies;
@@ -87,6 +92,28 @@ function getCursor(taskId) {
   return s.tasks[String(taskId || "")] || null;
 }
 
+// Mark that a task has had an agent turn emitted for it (from any source: a
+// socket/poll notification OR the reconciliation poll). The reconciliation poll
+// reads this to avoid re-engaging a task the socket already handled — dedup is
+// per-task, not per-notification-id, because a synthesised assignment has no
+// real notification id to match against.
+function markTaskEngaged(taskId) {
+  const id = String(taskId || "");
+  if (!id) return;
+  const s = load();
+  const cur = s.tasks[id] || { count: 0 };
+  cur.engaged = true;
+  cur.lastEngagedAt = new Date().toISOString();
+  s.tasks[id] = cur;
+  save();
+}
+
+function taskEngaged(taskId) {
+  const s = load();
+  const t = s.tasks[String(taskId || "")];
+  return !!(t && t.engaged);
+}
+
 function snapshot() {
   const s = load();
   return { tasks: s.tasks, processedCount: s.processed.length };
@@ -104,6 +131,17 @@ function markSocketConnected() {
   save();
 }
 
+// Called by the adapter's reconciliation poll after a successful listTasks().
+// Being able to list our own tasks is membership proof that survives socket
+// churn — so it's a first-class connection signal, not just a socket fallback.
+function markRestConnected() {
+  const s = load();
+  const now = Date.now();
+  if (!s.connection.restFirstAt) s.connection.restFirstAt = now;
+  s.connection.restLastAt = now;
+  save();
+}
+
 // Called by the connected-apps poller with central's authoritative answer to
 // "is Spaces among my connected apps?". Persisted so a restart keeps the signal
 // until the next poll refreshes it.
@@ -122,7 +160,7 @@ function setCentralConnected(connected) {
 // sticky signal.
 function isConnected() {
   const s = load();
-  return !!(s.connection.central || s.connection.socketFirstAt);
+  return !!(s.connection.central || s.connection.socketFirstAt || s.connection.restFirstAt);
 }
 
 // --- Owner control (from chat) ---------------------------------------------
@@ -164,6 +202,8 @@ function controlSnapshot() {
     central: s.connection.central,
     socketFirstAt: s.connection.socketFirstAt,
     socketLastAt: s.connection.socketLastAt,
+    restFirstAt: s.connection.restFirstAt,
+    restLastAt: s.connection.restLastAt,
     muted: s.control.muted,
     conversationalActive: conversationalActive(),
     taskLoopMode: taskLoopMode(),
@@ -172,7 +212,7 @@ function controlSnapshot() {
 }
 
 module.exports = {
-  markProcessed, recordCursor, getCursor, snapshot, STATE_FILE,
-  markSocketConnected, setCentralConnected, isConnected,
+  markProcessed, recordCursor, getCursor, markTaskEngaged, taskEngaged, snapshot, STATE_FILE,
+  markSocketConnected, markRestConnected, setCentralConnected, isConnected,
   setMuted, setTaskLoopMode, taskLoopMode, conversationalActive, controlSnapshot,
 };

package/core/config.js

@@ -259,6 +259,7 @@ function loadChannels() {
           // live. "advisory" = read/reason/recommend; "autonomous" = work to
           // completion (writes still hit the owner-approval gate); "off".
           taskLoopMode: String(config.OC_SPACES_TASK_LOOP || process.env.OC_SPACES_TASK_LOOP || "advisory").toLowerCase(),
+          pollMs: Number(config.OC_SPACES_POLL_MS || process.env.OC_SPACES_POLL_MS) || 60000,
         },
       });
     } else if (type === "voice") {
@@ -295,6 +296,7 @@ function loadChannels() {
         token: config.KAZEE_BOT_TOKEN,
         ownerUserId: config.SPACES_OWNER_USER_ID || "",
         taskLoopMode: String(config.OC_SPACES_TASK_LOOP || process.env.OC_SPACES_TASK_LOOP || "advisory").toLowerCase(),
+        pollMs: Number(config.OC_SPACES_POLL_MS || process.env.OC_SPACES_POLL_MS) || 60000,
       },
     });
   }

package/core/handlers.js

@@ -807,7 +807,7 @@ register({
     const fmtTime = (ms) => (ms ? new Date(ms).toISOString().replace("T", " ").slice(0, 16) + "Z" : "never");
     const statusText = () => {
       const s = spacesState.controlSnapshot();
-      const src = s.central ? "central" : (s.socketFirstAt ? "socket" : "—");
+      const src = s.central ? "central" : (s.socketFirstAt ? "socket" : (s.restFirstAt ? "poll" : "—"));
       const replies = s.conversationalActive ? "ON" : (s.connected ? "paused" : "off (not connected)");
       const modeLine = s.taskLoopOverride
         ? `${s.taskLoopMode} (override)`
@@ -818,6 +818,7 @@ register({
         `Auto-replies: ${replies}`,
         `Task mode: ${modeLine}`,
         `Last notification: ${fmtTime(s.socketLastAt)}`,
+        `Last poll: ${fmtTime(s.restLastAt)}`,
       ].join("\n");
     };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.0.17",
+  "version": "3.0.18",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {

package/test-provider-language.js

@@ -32,13 +32,15 @@ assert.doesNotMatch(setup, /Your Claude Code bot is connected|Description=Claude
 
 const pkg = JSON.parse(read("package.json"));
 assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
-// 3.0.17 approved by Sumeet 2026-07-14 ("Your call build and push"): Spaces
-// conversational plane now AUTO-ENABLES on connection (hybrid — central lists
-// Spaces OR the socket receives a notification) instead of the OC_SPACES_CONVERSATIONAL
-// env flag the owner can't reach on a pod. Control moves into chat via /spaces
-// (status|pause|resume|mode). The Spaces channel auto-includes whenever
-// KAZEE_BOT_TOKEN is set. Still self-gating: no Spaces membership ⇒ no replies.
-assert.strictEqual(pkg.version, "3.0.17", "release version must remain unchanged without explicit approval");
+// 3.0.18 approved by Sumeet 2026-07-14 ("Yeah, go for it build it push it out"):
+// the Spaces conversational plane now also RECONCILES against its task list. An
+// assignment creates a task but emits NO notification, and the socket-push-only
+// path missed it — so the adapter drives its own timer that calls listTasks()
+// (bot-scoped to assigned tasks) and synthesises a task_assigned engage for any
+// active task it hasn't engaged, with per-task dedup so the socket path isn't
+// doubled. A successful listTasks() is a third connection leg (markRestConnected)
+// that survives socket churn. Builds on 3.0.17's connection-based auto-enable.
+assert.strictEqual(pkg.version, "3.0.18", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }