@inetafrica/open-claudia 3.0.20 → 3.0.22

package/core/actions.js

@@ -575,19 +575,20 @@ async function handleAction(envelope) {
     };
     const p = presets[d.slice(3)];
     if (!p) return;
+    const cronProject = getProjectKey(state);
     scheduler.addJob({
       kind: "cron",
       adapter: envelope.adapter.id,
       adapterType: envelope.adapter.type,
       channelId: String(envelope.channelId),
       canonicalUserId: envelope.canonicalUserId,
-      project: state.currentSession.name,
+      project: cronProject,
       prompt: p.prompt,
       label: p.label,
       source: "user",
       schedule: p.schedule,
     });
-    await send(`Added: ${p.label} for ${state.currentSession.name}`);
+    await send(`Added: ${p.label} for ${cronProject}`);
     return;
   }
   if (d === "cp:clear") {

package/core/context.js

@@ -6,8 +6,8 @@ const { AsyncLocalStorage } = require("node:async_hooks");
 
 const chatContext = new AsyncLocalStorage();
 
-function runInChat({ adapter, channelId, canonicalUserId, userId, transport, raw }, fn) {
-  return chatContext.run({ adapter, channelId, canonicalUserId, userId, transport, raw }, fn);
+function runInChat({ adapter, channelId, canonicalUserId, userId, transport, raw, conversationKey }, fn) {
+  return chatContext.run({ adapter, channelId, canonicalUserId, userId, transport, raw, conversationKey }, fn);
 }
 
 function currentStore() {
@@ -44,6 +44,16 @@ function currentTransport() {
   return s ? s.transport : null;
 }
 
+// The per-thread conversation key for this turn (e.g. "telegram:6251055967",
+// "spaces:task:42"). Distinct from the (possibly unified) canonical speaker
+// identity: identity says WHO is talking, conversationKey says WHICH thread —
+// so the owner's Telegram DM and the owner's Spaces task keep separate live
+// conversations even though both resolve to the same canonical self.
+function currentConversationKey() {
+  const s = currentStore();
+  return s && s.conversationKey ? s.conversationKey : null;
+}
+
 module.exports = {
   chatContext,
   runInChat,
@@ -52,5 +62,6 @@ module.exports = {
   currentCanonicalUserId,
   currentUserId,
   currentTransport,
+  currentConversationKey,
   currentRaw,
 };

package/core/handlers.js

@@ -15,7 +15,7 @@ const { register } = require("./commands");
 const { send, deleteMessage } = require("./io");
 const {
   currentState, saveState, rootSession,
-  freshUsage, getActiveProvider, getProviderSession, setProviderSession, clearProviderSession,
+  freshUsage, getActiveProvider, getProjectKey, getProviderSession, setProviderSession, clearProviderSession,
   getProviderSettings,
   getProjectSessions, getLastProjectSession, userOwnsProviderSession,
   createSessionCallbackToken, linkIdentity,
@@ -207,7 +207,7 @@ function switchProviderState(providerId, options = {}) {
   };
   state.settings.backend = provider;
   if (Object.prototype.hasOwnProperty.call(options, "model")) state.settings.model = options.model;
-  const project = state.currentSession?.name || null;
+  const project = getProjectKey(state);
   if (project && !getProviderSession(state, provider, project)) {
     const last = getLastProjectSession(state.userId, project, provider);
     if (last) setProviderSession(state, provider, project, last.id);
@@ -237,9 +237,10 @@ function selectProjectState(project, options = {}) {
   clearTransientQueue(state, "Project changed before the queued run started");
   state.currentSession = { name: project.name.trim(), dir: project.dir || null };
   const provider = getActiveProvider(state);
-  const last = provider ? getLastProjectSession(state.userId, state.currentSession.name, provider) : null;
-  if (last) setProviderSession(state, provider, state.currentSession.name, last.id);
-  const sessionId = getProviderSession(state, provider, state.currentSession.name);
+  const key = getProjectKey(state);
+  const last = provider ? getLastProjectSession(state.userId, key, provider) : null;
+  if (last) setProviderSession(state, provider, key, last.id);
+  const sessionId = getProviderSession(state, provider, key);
   state.isFirstMessage = !sessionId;
   const persisted = persistSessionControl(state, options, () => {
     state.currentSession = previous.currentSession;
@@ -251,7 +252,7 @@ function selectProjectState(project, options = {}) {
 
 function startNewConversation(options = {}) {
   const state = options.state || currentState();
-  const project = state.currentSession?.name || null;
+  const project = getProjectKey(state);
   if (!project || (options.projectName && options.projectName !== project)) {
     return { ok: false, error: Object.assign(new Error("The selected project changed"), { code: "STALE_PROJECT" }) };
   }
@@ -277,7 +278,7 @@ function startNewConversation(options = {}) {
 function endCurrentSession(options = {}) {
   const state = options.state || currentState();
   const previous = { currentSession: state.currentSession, isFirstMessage: state.isFirstMessage };
-  const project = state.currentSession?.name || "Workspace";
+  const project = getProjectKey(state) || "Workspace";
   clearTransientQueue(state, "The conversation ended before the queued run started");
   state.currentSession = rootSession();
   state.isFirstMessage = true;
@@ -292,7 +293,7 @@ function endCurrentSession(options = {}) {
 function activeContinueOptions(state = currentState()) {
   const provider = getActiveProvider(state);
   if (!provider) return null;
-  const sessionId = getProviderSession(state, provider, state.currentSession?.name);
+  const sessionId = getProviderSession(state, provider, getProjectKey(state));
   return sessionId ? { provider, resumeSessionId: sessionId } : null;
 }
 
@@ -301,7 +302,7 @@ function activeContinueOptions(state = currentState()) {
 function startSession(name, resumeSessionId, options = {}) {
   const state = currentState();
   const provider = options.provider || getActiveProvider(state);
-  const projectName = "Workspace";
+  const projectName = getProjectKey(state);
 
   if (!provider) return send("Choose Claude Code or OpenAI Codex with /backend before starting a conversation.");
 
@@ -891,10 +892,10 @@ register({
     const state = currentState();
     const provider = getActiveProvider(state);
     if (!provider) return send("Choose Claude Code or OpenAI Codex with /backend first.");
-    const project = state.currentSession.name;
+    const project = getProjectKey(state);
     const sessions = getProjectSessions(state.userId, project, provider)
       .filter((session) => session.selectable !== false);
-    if (sessions.length === 0) return send("No past conversations for this project.");
+    if (sessions.length === 0) return send("No past conversations in this thread.");
     const rows = sessions.slice(0, 10).map((s) => {
       const date = new Date(s.lastUsed).toLocaleDateString();
       const active = getProviderSession(state, provider, project) === s.id ? " (active)" : "";
@@ -905,12 +906,12 @@ register({
         sessionId: s.id,
       });
       return [{
-        text: `${s.title}${active} · ${s.provider} · ${project} — ${date}`,
+        text: `${s.title}${active} · ${s.provider} — ${date}`,
         callback_data: `ss:${token}`,
       }];
     });
-    rows.push([{ text: "New conversation", callback_data: `new:${state.currentSession.name}` }]);
-    send(`Conversations in ${state.currentSession.name}:`, { keyboard: { inline_keyboard: rows } });
+    rows.push([{ text: "New conversation", callback_data: `new:${project}` }]);
+    send(`Conversations in this thread:`, { keyboard: { inline_keyboard: rows } });
   },
 });
 

package/core/identity.js

@@ -18,6 +18,14 @@ function defaultCanonicalForChannel(transport, channelId) {
   return channelKey(transport, channelId);
 }
 
+// The conversation (thread) key for a channel. Deliberately identical to the
+// pre-unification default canonical: a thread is keyed by its raw channel
+// identity, never by the unified speaker canonical. This is what keeps each
+// surface's live conversation separate even when the speaker is one being.
+function conversationKeyFor(transport, channelId) {
+  return channelKey(transport, channelId);
+}
+
 function loadIdentities() {
   const raw = readJsonWithFallback(IDENTITIES_FILE, null);
   return {
@@ -187,6 +195,7 @@ module.exports = {
   normalizeCanonicalUserId,
   channelKey,
   defaultCanonicalForChannel,
+  conversationKeyFor,
   isConfiguredOwnerChannel,
   ownerCanonical,
   channelIsOwner,

package/core/router.js

@@ -5,6 +5,7 @@
 const fs = require("fs");
 const path = require("path");
 const { runInChat } = require("./context");
+const { conversationKeyFor } = require("./identity");
 const { dispatch } = require("./commands");
 const { handleAction } = require("./actions");
 const { isChatAuthorized } = require("./access");
@@ -79,6 +80,7 @@ function scope(envelope, fn) {
     userId: envelope.userId,
     transport: envelope.adapter?.type,
     raw: envelope.raw,
+    conversationKey: conversationKeyFor(envelope.adapter?.type, envelope.channelId),
   }, fn);
 }
 

package/core/run-context.js

@@ -2,6 +2,7 @@
 
 const crypto = require("crypto");
 const path = require("path");
+const { currentConversationKey } = require("./context");
 
 function cloneSerializable(value, label = "run context value") {
   if (value === undefined) return undefined;
@@ -23,7 +24,18 @@ function deepFreeze(value, seen = new Set()) {
 }
 
 function projectSnapshot(state, cwd, requestedProject) {
-  const value = requestedProject !== undefined ? requestedProject : state.currentSession;
+  let value = requestedProject;
+  if (value === undefined) {
+    // No explicit project ⇒ this is a live chat turn: key the conversation
+    // (provider session) by the per-thread conversation key so each surface
+    // keeps its own session. dir stays the workspace root. Outside a turn
+    // (background jobs, tests) there is no conversation key ⇒ fall back to the
+    // shared currentSession, preserving prior behaviour byte-for-byte.
+    const convo = currentConversationKey();
+    value = convo
+      ? { name: convo, dir: state.currentSession?.dir || cwd || null }
+      : state.currentSession;
+  }
   if (value && typeof value === "object") {
     const dir = value.dir || value.path || cwd || null;
     return {
@@ -146,7 +158,13 @@ function sameCapturedProject(state, runContext) {
   const live = state?.currentSession;
   const captured = runContext?.project;
   if (!live || !captured) return !live && !captured;
-  return String(live.name || "") === String(captured.name || "")
+  // "Same project" now means "same live conversation thread". Compare the
+  // captured key against the live conversation key (falling back to the shared
+  // currentSession name outside a chat turn), so a run that resumes/compacts is
+  // matched to the thread it was admitted on — not to whichever thread most
+  // recently touched the shared currentSession.
+  const liveName = currentConversationKey() || live.name || "";
+  return String(liveName) === String(captured.name || "")
     && String(live.dir || live.path || "") === String(captured.dir || captured.path || "");
 }
 

package/core/scheduler.js

@@ -328,6 +328,10 @@ function createSchedulerService(dependencies = {}) {
       userId,
       transport: adapter.type,
       raw: null,
+      // Key the resumed conversation by the job's saved thread, not the live
+      // shared session. Matches captured project.name (projectDescriptor(job).name)
+      // so sameCapturedProject / getProjectKey resolve the right thread mid-run.
+      conversationKey: projectDescriptor(job).name,
     };
 
     return runInChat(chat, async () => {

package/core/state.js

@@ -20,7 +20,7 @@ const {
   channelKey,
   identities,
 } = require("./identity");
-const { currentChannelId, currentCanonicalUserId } = require("./context");
+const { currentChannelId, currentCanonicalUserId, currentConversationKey } = require("./context");
 const { atomicWriteFileSync, readJsonWithFallback } = require("./fsutil");
 const {
   defaultMigrationSources,
@@ -385,7 +385,16 @@ function getActiveProvider(state) {
 }
 
 function getProjectKey(state, projectName) {
-  return projectNameFrom(projectName === undefined ? state?.currentSession : projectName);
+  if (projectName !== undefined) return projectNameFrom(projectName);
+  // Conversation-per-thread: with no explicit project the caller means "the
+  // current thread", whose key is the live conversation key — so each surface
+  // (Telegram DM, Spaces task, Kazee chat) owns a separate provider session and
+  // usage bucket, even when they resolve to one unified canonical speaker.
+  // Outside a chat turn (background jobs, CLI, tests) there is no conversation
+  // key, so we fall back to currentSession — byte-identical to prior behaviour.
+  const convo = currentConversationKey();
+  if (convo) return convo;
+  return projectNameFrom(state?.currentSession);
 }
 
 function getProviderSession(state, providerId, projectName) {
@@ -558,6 +567,48 @@ function createUserState(userId) {
   return state;
 }
 
+// Carry the legacy shared "Workspace" conversation into its per-thread key on
+// the channel that owns it, so moving to conversation-per-thread keying never
+// resets a live conversation. In-memory + non-destructive: the "Workspace"
+// bucket is copied (not moved) and the natural post-run save persists it, so a
+// restart before that save simply re-seeds deterministically. Only the "home"
+// channel — the one whose raw identity equals this state's canonical — inherits
+// it; secondary unified channels (the owner's Spaces task) start clean, which
+// is the whole point (they must not resume another thread's session).
+function seedConversationContinuity(state) {
+  const convo = currentConversationKey();
+  if (!convo || convo === "Workspace") return;
+  if (normalizeCanonicalUserId(convo) !== normalizeCanonicalUserId(state.userId)) return;
+  if (!isRecord(state.activeSessions)) return;
+  const legacy = state.activeSessions.Workspace;
+  if (!isRecord(legacy) || isRecord(state.activeSessions[convo])) return;
+  state.activeSessions[convo] = { ...legacy };
+  if (isRecord(state.usageBySession)) {
+    const prefix = "Workspace";
+    for (const [key, usage] of Object.entries(state.usageBySession)) {
+      if (key.startsWith(prefix) && isRecord(usage)) {
+        const moved = `${convo}${key.slice(prefix.length)}`;
+        if (!state.usageBySession[moved]) state.usageBySession[moved] = { ...usage };
+      }
+    }
+    state.usageBySession = boundUsageBySession(state.usageBySession);
+  }
+  // Carry the shared "Workspace" session history (sessions.json) into the
+  // per-thread key too, so /sessions listing and resume-ownership checks — both
+  // keyed by conversationKey — keep the home channel's existing conversations.
+  // Best-effort and run-once: reached only on the same first call that seeds
+  // activeSessions above (later calls early-return at the activeSessions guard).
+  try {
+    const uid = normalizeCanonicalUserId(state.userId);
+    const all = loadSessions();
+    const userSessions = all[uid];
+    if (isRecord(userSessions) && Array.isArray(userSessions.Workspace) && !userSessions[convo]) {
+      userSessions[convo] = userSessions.Workspace.map((record) => ({ ...record, project: convo }));
+      saveSessions(all, { strict: false });
+    }
+  } catch (e) {}
+}
+
 function getUserState(userId) {
   const id = normalizeCanonicalUserId(userId);
   if (!userStates.has(id)) userStates.set(id, createUserState(id));
@@ -571,6 +622,7 @@ function getUserState(userId) {
     }
   }
   state.channelId = currentChannelId() || state.channelId;
+  try { seedConversationContinuity(state); } catch (e) {}
   return state;
 }
 

package/core/turn-observer.js

@@ -32,6 +32,16 @@ function createTurnObserver({ state, store }) {
   try { guarded = chatContext.run(store, () => require("./relationship").isCurrentSpeakerGuarded()); }
   catch (e) { guarded = true; }
 
+  // Spaces is a customer-facing surface that renders neither Telegram HTML nor
+  // internal recall/tool banners meaningfully — a <b> banner shows the literal
+  // tags. Suppress all owner-only chat visibility there; memory + graph feeding
+  // still run, only the chat emissions are muted.
+  let suppressChatVisibility = false;
+  try {
+    const adapter = chatContext.run(store, () => currentAdapter());
+    suppressChatVisibility = adapter?.type === "spaces";
+  } catch (e) { suppressChatVisibility = false; }
+
   const packsLib = require("./packs");
   const entitiesLib = require("./entities");
   const toolsLib = require("./tools");
@@ -40,7 +50,7 @@ function createTurnObserver({ state, store }) {
   // Deduped per turn: a node touched twice announces once.
   const notified = new Set();
   const notify = (key, text, opts) => {
-    if (guarded) return;
+    if (guarded || suppressChatVisibility) return;
     if (notified.has(key)) return;
     notified.add(key);
     try { chatContext.run(store, () => send(text, opts).catch(() => {})); }

package/package.json

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

package/test-provider-gateway.js

@@ -404,6 +404,7 @@ function queueProbe() {
     currentChannelId: () => store.channelId,
     currentAdapter: () => store.adapter,
     currentUserId: () => store.userId,
+    currentConversationKey: () => store.conversationKey || null,
   });
   installStub("./core/io", {
     send: async () => ({ ok: true, messageId: "queued", editable: true }),

package/test-provider-language.js

@@ -32,14 +32,18 @@ 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.20 approved by Sumeet 2026-07-14 ("Yeh push it"): two Spaces fixes. (1)
-// The Spaces server emits PLURAL notification categories (mentions/comments/
-// reactions), so ENGAGE_TYPES now matches "mentions"/"replies" — matching only
-// singular "mention" silently dropped every real tag. (2) isConfiguredOwnerChannel
-// gained a "spaces" branch mapping to KAZEE_OWNER_USER_ID (Spaces principals are
-// central/Kazee ids), so the owner is no longer classed external (default-deny)
-// on their own Spaces comments. 3.0.19 flattened the folder-project model.
-assert.strictEqual(pkg.version, "3.0.20", "release version must remain unchanged without explicit approval");
+// 3.0.22 approved by Sumeet 2026-07-14 ("Yeh push out"): per-thread conversations
+// + Spaces output hygiene. The live conversation now keys by THREAD
+// (transport:channelId via currentConversationKey off AsyncLocalStorage) instead
+// of by canonical identity alone, so Telegram DM and each Spaces task get isolated
+// sessions/transcripts while memory + guardrails + soul stay one global brain.
+// seedConversationContinuity does a one-time non-destructive COPY of the legacy
+// "Workspace" session/usage/history into the home conversationKey (anchored by
+// canonical match; secondary channels start clean). turn-observer suppresses the
+// Spaces <b> banner + tool-trace leak. 3.0.21 shipped the same work but its CI
+// build failed on THIS gate (package.json bumped without the assertion) — nothing
+// published under 3.0.21; 3.0.22 is the corrected re-ship.
+assert.strictEqual(pkg.version, "3.0.22", "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}`);
 }