@inetafrica/open-claudia 3.5.1 → 3.5.4

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 3.5.4
+
+Parallel conversations in Kazee Chat threads, with the fixes from an independent review. Canary first, on the owner's own bot. (3.5.2 and 3.5.3 were tagged but never published: 3.5.2 failed its release test, 3.5.3 was cancelled for this build.)
+
+- **A Kazee thread is its own conversation with the bot.** "Reply in thread" on any message starts a conversation that runs alongside the main chat and the other threads: its own session, transcript, queue, typing indicator and live preview, and the bot answers inside the thread. Up to 4 conversations run at once per person (`OC_MAX_PARALLEL_TURNS`) and 8 across the bot (`OC_MAX_PARALLEL_TURNS_GLOBAL`). Past that a message waits, says so, and starts when a slot frees. Inside one conversation turns still run one at a time.
+- **A new thread starts "hybrid":** the message it hangs off, the replies so far, and the last 10 main-chat messages before it, not the whole history. `OC_THREAD_SEED=fresh` leaves the main messages out; `OC_THREAD_SEED=fork` (Claude) resumes the main conversation into the thread instead.
+- **`/stop` stops only the conversation it is sent in, and drops the messages queued in it before the /stop,** naming them (`Cancelled. Dropped 2 queued: "reboot pe2", "and check the…"`). A conversation that is only waiting for a free slot drops its waiting messages the same way. `/stop all` does both for every conversation. A message sent after the /stop still runs. `/status` lists the conversations running now.
+- **Everything a thread turn starts comes back to that thread:** wake-ups, watches and crons, files, photos and voice notes, approvals. A button pressed on a message the bot posted in a thread runs in that thread.
+- **Groups:** a thread reply engages the bot when it is @mentioned, when the bot posted the thread's first message, or once the bot has replied in that thread. The main-chat catch-up leaves thread-only replies out.
+- **A refused thread never loses a reply:** if Kazee Chat refuses the thread (for example its first message was deleted), the reply goes to the main chat, quoting that message.
+- **Fixes from the review:** no typing indicator for a message that waits for a slot (it could stay on for good); a /stop during a compaction no longer eats the next message; in groups, a thread the bot replied in keeps engaging it even when the reply's id came back empty; a button pressed after a restart still runs in its thread; a job made in a forked thread never resumes the main conversation (`OC_THREAD_SEED=fork`); a job also waits for the conversation it replies into; a stuck run's late exit never frees a conversation another run holds; a turn can only post into its own thread; a Kazee send is never repeated because of bookkeeping; recall keeps a quiet conversation's own recent turns while other threads are busy.
+- **Fix:** compaction read the wrong conversation's recent turns (the legacy "Workspace" transcript) when it summarised.
+- **Changed:** background runs that have no chat now run beside chat conversations instead of queueing behind them, and count toward the caps.
+- **Note:** this release also carries 3.5.0 and 3.5.1 (permission phase 0). The fleet's containers still need the bubblewrap fix for staff turns before any roll; this canary is for one bot on macOS, where the environment scrub works.
+
 ## 3.5.1
 
 Hardening after an adversarial review of 3.5.0, before any of it reaches the fleet. Canary first.

package/bin/cli.js

@@ -56,18 +56,26 @@ function sendViaLoopback(kind, restArgs) {
   const stat = fs.statSync(filePath);
   const params = new URLSearchParams({ channelId, adapter: adapterId, fileName });
   if (process.env.OC_CHANNEL_USER_ID) params.set("userId", process.env.OC_CHANNEL_USER_ID);
+  // A thread turn's file goes back into its thread.
+  if (process.env.OC_THREAD_ID) params.set("threadId", process.env.OC_THREAD_ID);
   if (caption) params.set("caption", caption);
+  const headers = {
+    Authorization: `Bearer ${sendToken}`,
+    "Content-Type": "application/octet-stream",
+    "Content-Length": stat.size,
+  };
+  // The run's attest lets the bot check the thread against the live run.
+  if (process.env.OC_RUN_ID && process.env.OC_RUN_ATTEST) {
+    headers["X-OC-Run-Id"] = process.env.OC_RUN_ID;
+    headers["X-OC-Run-Attest"] = process.env.OC_RUN_ATTEST;
+  }
 
   const req = http.request({
     method: "POST",
     hostname: u.hostname,
     port: u.port,
     path: `/${kind}?${params.toString()}`,
-    headers: {
-      Authorization: `Bearer ${sendToken}`,
-      "Content-Type": "application/octet-stream",
-      "Content-Length": stat.size,
-    },
+    headers,
   }, (res) => {
     let body = "";
     res.on("data", (c) => { body += c; });

package/bin/loopback-client.js

@@ -41,6 +41,9 @@ function context() {
     sendUrl,
     sendToken,
     channelId: process.env.OC_CHANNEL_ID,
+    // The chat thread the turn is in (set by the runner for thread turns):
+    // files, voice and jobs from this turn go back into that thread.
+    threadId: process.env.OC_THREAD_ID || null,
     adapterId: process.env.OC_CHANNEL_ADAPTER,
     userId: process.env.OC_CHANNEL_USER_ID || null,
     canonicalUserId: process.env.OC_CANONICAL_USER_ID || null,
@@ -91,6 +94,7 @@ function postJson(kind, body, { verified = false } = {}) {
     ...body,
     ...(kind === "call-say" ? { callSpeechToken: process.env.OC_CALL_SPEECH_TOKEN || "" } : {}),
     channelId: ctx.channelId,
+    threadId: ctx.threadId,
     adapter: ctx.adapterId,
     userId: ctx.userId,
     canonicalUserId: ctx.canonicalUserId,

package/bin/schedule.js

@@ -85,6 +85,11 @@ function jobProgress(j) {
   return state ? `${since}${state}` : "";
 }
 
+// A job created in a chat thread fires back into that thread.
+function threadMarker(j) {
+  return j.threadId ? `  (thread ${String(j.threadId).slice(-6)})` : "";
+}
+
 function fmtJob(j) {
   const when = j.kind === "wakeup"
     ? `fires ${new Date(j.fireAt).toISOString()}`
@@ -92,7 +97,7 @@ function fmtJob(j) {
   const proj = j.project ? ` [${j.project}]` : "";
   const src = j.source ? ` (${j.source})` : "";
   const progress = jobProgress(j);
-  return `${j.id}  ${j.kind}  ${j.label || "(no label)"}${proj}${src}  ${when}${progress ? `  [${progress}]` : ""}`;
+  return `${j.id}  ${j.kind}  ${j.label || "(no label)"}${proj}${src}${threadMarker(j)}  ${when}${progress ? `  [${progress}]` : ""}`;
 }
 
 function fmtWatch(w, now = Date.now()) {
@@ -104,7 +109,7 @@ function fmtWatch(w, now = Date.now()) {
         ? "  EXPIRED (fires on next poll)"
         : `  expires ${new Date(Number(w.expiresAt)).toISOString()}`)
       : "  no expiry (pre-timeout watch)";
-  return `${w.id}  ${mode}  polls "${w.schedule}"${expiry}  check: ${w.check}  → ${w.label || "(no label)"}`;
+  return `${w.id}  ${mode}${threadMarker(w)}  polls "${w.schedule}"${expiry}  check: ${w.check}  → ${w.label || "(no label)"}`;
 }
 
 async function runScheduleWakeup(args) {

package/bot.js

@@ -131,9 +131,13 @@ async function gracefulShutdown(signal) {
       console.error("memory shutdown drain failed:", error?.message);
       return { drained: false };
     });
+  // Every running conversation (main timeline and each thread) has its own
+  // process on its own lane.
   for (const state of userStates.values()) {
-    if (state.runningProcess) {
-      try { killProcessTree(state.runningProcess.pid, "SIGTERM"); } catch (e) {}
+    if (!(state.lanes instanceof Map)) continue;
+    for (const lane of state.lanes.values()) {
+      if (!lane.runningProcess) continue;
+      try { killProcessTree(lane.runningProcess.pid, "SIGTERM"); } catch (e) {}
     }
   }
   await Promise.all([sideCleanup, memoryCleanup]);