@inetafrica/open-claudia 3.5.1 → 3.5.7

package/.env.example

@@ -50,6 +50,19 @@ AUTO_COMPACT_TOKENS=280000
 # Inactivity watchdog: kill a heavy turn's child if it emits no output for
 # this many ms, so a hung tool call can't wedge the bot. Default 600000 (10min).
 OC_TURN_IDLE_MS=600000
+# Kazee Chat threads: each thread is its own conversation. Running turns per
+# person / across the bot; how a new thread starts (hybrid | fresh | fork);
+# and whether the bot names a thread it talks in once it knows the topic
+# (only when the thread has no title yet; a person's title always stays).
+OC_MAX_PARALLEL_TURNS=4
+OC_MAX_PARALLEL_TURNS_GLOBAL=8
+OC_THREAD_SEED=hybrid
+# on (default) | off
+OC_THREAD_TITLES=on
+# Utility provider/model for thread titles (default: the utility defaults).
+THREAD_TITLE_PROVIDER=
+THREAD_TITLE_MODEL_CLAUDE=
+THREAD_TITLE_MODEL_CODEX=
 USAGE_ALERT_CONTEXT_TOKENS=120000
 USAGE_ALERT_RATE_MULTIPLIER=1.75
 USAGE_ALERT_BASELINE_TURNS=20

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 3.5.7
+
+3.5.6 as it was meant to ship: the same bot, with one test fixed so the release can build. Canary first on network-bot and procurement-specialist, then the fleet.
+
+- **Build fix only.** The 3.5.5 thread-naming test drove a real turn that needed Claude Code installed on the machine running the tests. The build server has none, so the 3.5.5 and 3.5.6 builds failed and neither was published. The test now uses the fake agent the other tests use. Nothing changes in the bot itself.
+
+## 3.5.6
+
+Ready for every bot: the Kazee threads releases (3.5.2-3.5.5) plus the fix that kept them off the fleet. Canary first on network-bot and procurement-specialist, then the fleet.
+
+- **Fix: staff messages work in the bots' containers again.** 3.5.1 hid the AI credentials from staff members' turns (`CLAUDE_CODE_SUBPROCESS_ENV_SCRUB`), which on Linux needs bubblewrap with user namespaces. The fleet's containers have neither, so Claude Code refused to start and every staff message crashed (network-bot, 26 Sep). The bot now checks once whether that sandbox can run and turns the scrub on only where it can (macOS, or Linux with working bubblewrap); elsewhere a staff turn runs as it did on 3.4.x. The log says which, and why. `OC_STAFF_ENV_SCRUB=on|off` overrides the check.
+- **The fleet gets everything since 3.4.24:** parallel conversations in Kazee threads (3.5.2-3.5.4), thread naming (3.5.5), and permission phase 0 (3.5.0-3.5.1).
+
+## 3.5.5
+
+The bot names the Kazee threads it talks in. Canary first, on the owner's own bot.
+
+- **A thread gets a title once the bot knows the topic.** After the bot's first delivered reply in a Kazee thread, it asks the utility model for a short title (3-6 plain words, at most 60 characters, the conversation's language) and sets it on the thread for everyone in the chat. It never overwrites a title a person gave (`onlyIfUnset`), names a thread once (remembered across restarts), never names the main chat, and never delays or blocks a reply. A failure is logged once and never shown in the chat; a transient one is retried once, on the thread's next turn.
+- **Needs Kazee Chat's thread titles** (chat-central with `POST /api/thread/:chatId/:rootId/title`). An older server answers 404: naming pauses for an hour, then tries again.
+- **Settings:** `OC_THREAD_TITLES=off` turns it off (on by default); `THREAD_TITLE_PROVIDER` and `THREAD_TITLE_MODEL_<CLAUDE|CODEX>` pick the model (utility defaults otherwise). The thread settings are now documented together in `.env.example`.
+
+## 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]);