@inetafrica/open-claudia 3.0.17 → 3.0.19

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## v3.0.19 — flattened to the top level (the folder-project model is gone)
+
+- **The bot always runs at the top-level workspace now — no more "Pick a project first."** The per-folder session model (pick a subfolder of `WORKSPACE`, scope the conversation to it) has been removed. `currentSession` defaults to the workspace root (`{ name: "Workspace", dir: WORKSPACE }`) at state creation and on every migration/load, so it is never null. This directly fixes Spaces (and any non-Telegram channel that never picked a folder) replying with a dead "Pick a project first:" project-picker instead of engaging — the picker gate was the only thing blocking it.
+- **Removed the folder-picker surface.** Gone: `/projects`, `/session`, the project-selection inline keyboard, and the `show:projects` / `s:<name>` button callbacks. Also removed the four media "Pick a project first." gates (voice/audio/photo/document) and the text-handler gate in the router — all dead once a session always exists. `core/projects.js` is deleted.
+- **Conversation-level controls are unchanged.** `/sessions` (list past conversations), `/new` (fresh conversation), `/continue` (resume), `/end` (end current conversation — now resets to the root instead of clearing to null) all work as before, just always scoped to the one top-level workspace.
+- **`/cron add` no longer takes a `<project>` argument** — it schedules at the workspace root: `/cron add "<schedule>" "<prompt>"`. Existing crons with a stored project still resolve via the scheduler's descriptor.
+- **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.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/README.md

@@ -145,15 +145,16 @@ Each provider keeps its own persistent project session. Switching doesn't lose y
 
 ### Session management
 
+The bot runs at the top-level workspace; there is no per-folder project selection.
+
 | Command | Description |
 |---------|-------------|
-| `/session [<project>]` | Pick a project to work on |
-| `/sessions` | List past conversations for current project |
-| `/projects` | Browse all workspace projects |
+| `/new` | Start a fresh conversation |
+| `/sessions` | List past conversations |
 | `/continue` | Resume last conversation explicitly |
 | `/compact` | Summarize conversation context now |
 | `/compactwindow [<tokens> \| off \| default]` | Set the auto-compact token threshold |
-| `/end` | End current session |
+| `/end` | End the current conversation |
 
 When you select a project, the last conversation is automatically resumed. Tap "New conversation" to start fresh.
 
@@ -352,7 +353,7 @@ Foreground turns never silently fall back to a different provider. Utility work
 
 Conversation identity is the tuple of canonical user, project, provider, and native session ID. Claude Code and Codex histories and active pointers stay separate: switching providers restores only that provider's project session and never passes one provider's native session ID to another. Session-history entries are provider-tagged; ambiguous legacy records remain visible but non-selectable.
 
-Model, effort, budget, permission mode, and worktree settings are stored per provider. `/new` clears only the selected project/provider pointer, while `/end` closes the project selection without deleting history. Compaction and scheduled jobs capture an immutable provider/session tuple; an explicitly configured scheduled fallback starts fresh from a provider-neutral archived brief.
+Model, effort, budget, permission mode, and worktree settings are stored per provider. `/new` clears only the active provider's conversation pointer, while `/end` ends the current conversation (resetting to the top-level workspace) without deleting history. Compaction and scheduled jobs capture an immutable provider/session tuple; an explicitly configured scheduled fallback starts fresh from a provider-neutral archived brief.
 
 ## Provider migration and rollback
 
@@ -517,9 +518,9 @@ For direct npm installs, `/upgrade` updates Open Claudia itself and does not ins
 Schedule recurring tasks:
 
 ```
-/cron add "0 9 * * 1-5" myproject "Morning standup: summarize git changes since yesterday"
-/cron add "0 18 * * *" myproject "Git digest: what changed today?"
-/cron add "*/30 * * * *" myproject "Health check: verify the API is responding"
+/cron add "0 9 * * 1-5" "Morning standup: summarize git changes since yesterday"
+/cron add "0 18 * * *" "Git digest: what changed today?"
+/cron add "*/30 * * * *" "Health check: verify the API is responding"
 ```
 
 Presets available via `/cron` menu. The agent can also schedule its own jobs with `open-claudia cron-add` / `schedule-wakeup` (see Background Work).

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/actions.js

@@ -12,7 +12,6 @@ const {
   userOwnsProviderSession,
 } = require("./state");
 const { admitRunContext, runAgent } = require("./runner");
-const { listProjects, projectKeyboard } = require("./projects");
 const { isChatOwner, approveAuthRequest, denyAuthRequest, authRequestLabel } = require("./access");
 const accessStore = require("./access");
 const peopleStore = require("./people");
@@ -282,8 +281,6 @@ async function handleAction(envelope) {
 
   if (d.startsWith("ob:")) { finishOnboarding(d.slice(3)); return; }
 
-  if (d === "show:projects") { await send("Pick:", { keyboard: projectKeyboard() }); return; }
-  if (d.startsWith("s:")) { startSession(d.slice(2)); return; }
   if (d.startsWith("ss:")) {
     const resolved = resolveSessionCallbackAction(d.slice(3), state);
     if (resolved.status !== "ok") {
@@ -299,7 +296,7 @@ async function handleAction(envelope) {
     const expected = proj === "__workspace__" ? "Workspace" : proj;
     const result = startNewConversation({ state, projectName: expected });
     if (!result.ok) return send("That new-conversation button is stale. Open /sessions again.");
-    await send(`Session: ${state.currentSession.name}\nNew conversation\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
+    await send("New conversation\n\nSend text, voice, or images.\n\n/sessions — switch conversation");
     return;
   }
   if (d === "a:continue") {
@@ -310,11 +307,9 @@ async function handleAction(envelope) {
     });
   }
   if (d === "a:end") {
-    if (state.currentSession) {
-      const result = endCurrentSession({ state });
-      if (!result.ok) return send(`Could not end session: ${result.error.message}`);
-      await send(`Ended: ${result.project}`, { keyboard: { inline_keyboard: [[{ text: "New", callback_data: "show:projects" }]] } });
-    }
+    const result = endCurrentSession({ state });
+    if (!result.ok) return send(`Could not end conversation: ${result.error.message}`);
+    await send("Ended. Send anything to start a fresh conversation.");
     return;
   }
   if (d === "noop") return;

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

@@ -14,7 +14,7 @@ const {
 const { register } = require("./commands");
 const { send, deleteMessage } = require("./io");
 const {
-  currentState, saveState,
+  currentState, saveState, rootSession,
   freshUsage, getActiveProvider, getProviderSession, setProviderSession, clearProviderSession,
   getProviderSettings,
   getProjectSessions, getLastProjectSession, userOwnsProviderSession,
@@ -23,7 +23,6 @@ const {
 const { canonicalForChannel, canonicalForTelegram, normalizeCanonicalUserId, channelKey, identities, isConfiguredOwnerChannel, removeIdentityMapping } = require("./identity");
 const { isChatAuthorized, isChatOwner, recordPendingAuthRequest, authRequestLabel, hasOwner, bootstrapOwner } = require("./access");
 const { isOnboarded, startOnboarding } = require("./onboarding");
-const { listProjects, findProject, projectKeyboard } = require("./projects");
 const { vault } = require("./vault-store");
 const keyring = require("./keyring");
 const { redactSensitive, registerSecrets } = require("./redact");
@@ -60,10 +59,13 @@ function ownerEnv(envelope) {
   return isChatOwner(envelope.channelId);
 }
 
+// Everything runs at the top-level workspace now, so there is nothing to gate
+// on: ensure a root session exists and always proceed.
 function requireSession() {
-  if (!currentState().currentSession) {
-    send("Pick a project first:", { keyboard: projectKeyboard() });
-    return false;
+  const state = currentState();
+  if (!state.currentSession) {
+    state.currentSession = rootSession();
+    saveState();
   }
   return true;
 }
@@ -274,11 +276,10 @@ function startNewConversation(options = {}) {
 
 function endCurrentSession(options = {}) {
   const state = options.state || currentState();
-  if (!state.currentSession) return { ok: false, error: Object.assign(new Error("No session"), { code: "NO_SESSION" }) };
   const previous = { currentSession: state.currentSession, isFirstMessage: state.isFirstMessage };
-  const project = state.currentSession.name;
-  clearTransientQueue(state, "The project session ended before the queued run started");
-  state.currentSession = null;
+  const project = state.currentSession?.name || "Workspace";
+  clearTransientQueue(state, "The conversation ended before the queued run started");
+  state.currentSession = rootSession();
   state.isFirstMessage = true;
   state.cancelRequested = false;
   const persisted = persistSessionControl(state, options, () => {
@@ -295,29 +296,21 @@ function activeContinueOptions(state = currentState()) {
   return sessionId ? { provider, resumeSessionId: sessionId } : null;
 }
 
+// Resume a past conversation at the top-level workspace. Folder selection is
+// gone; `name` is retained for the recorded project key (always "Workspace").
 function startSession(name, resumeSessionId, options = {}) {
   const state = currentState();
   const provider = options.provider || getActiveProvider(state);
-  let projectName, projectDir;
-  if (name === "__workspace__") {
-    projectName = "Workspace";
-    projectDir = WORKSPACE;
-  } else {
-    const result = findProject(name);
-    if (!result) return send(`No match for "${name}".`, { keyboard: projectKeyboard() });
-    if (Array.isArray(result)) return send("Multiple matches:", { keyboard: { inline_keyboard: result.map((p) => [{ text: p, callback_data: `s:${p}` }]) } });
-    projectName = result;
-    projectDir = path.join(WORKSPACE, result);
-  }
+  const projectName = "Workspace";
 
-  if (!provider) return send("Choose Claude Code or OpenAI Codex with /backend before opening a project session.");
+  if (!provider) return send("Choose Claude Code or OpenAI Codex with /backend before starting a conversation.");
 
   if (resumeSessionId && !userOwnsProviderSession(state.userId, projectName, provider, resumeSessionId)) {
-    return send("That conversation is unavailable for this project and provider. Open /sessions again.");
+    return send("That conversation is unavailable for this provider. Open /sessions again.");
   }
 
-  const selected = selectProjectState({ name: projectName, dir: projectDir }, { state, persist: false });
-  if (!selected.ok) return send(`Could not select project: ${selected.error.message}`);
+  const selected = selectProjectState(rootSession(), { state, persist: false });
+  if (!selected.ok) return send(`Could not start conversation: ${selected.error.message}`);
 
   if (resumeSessionId) {
     setProviderSession(state, provider, projectName, resumeSessionId);
@@ -326,21 +319,21 @@ function startSession(name, resumeSessionId, options = {}) {
     const title = s ? s.title : "";
     state.isFirstMessage = false;
     saveState();
-    send(`Session: ${projectName}\nResumed: ${title || resumeSessionId.slice(0, 8)}\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
+    send(`Resumed: ${title || resumeSessionId.slice(0, 8)}\n\nSend text, voice, or images.\n\n/sessions — switch conversation`);
   } else {
     const last = getLastProjectSession(state.userId, projectName, provider);
     if (last) {
       setProviderSession(state, provider, projectName, last.id);
       state.isFirstMessage = false;
       saveState();
-      send(`Session: ${projectName}\nResumed: ${last.title}\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`, {
+      send(`Resumed: ${last.title}\n\nSend text, voice, or images.\n\n/sessions — switch conversation`, {
         keyboard: { inline_keyboard: [[{ text: "New conversation", callback_data: `new:${projectName}` }]] },
       });
     } else {
       const existing = getProviderSession(state, provider, projectName);
       state.isFirstMessage = !existing;
       saveState();
-      send(`Session: ${projectName}${existing ? `\nResumed: ${existing.slice(0, 8)}` : ""}\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
+      send(`Ready.${existing ? `\nResumed: ${existing.slice(0, 8)}` : ""}\n\nSend text, voice, or images.\n\n/sessions — switch conversation`);
     }
   }
 }
@@ -361,7 +354,8 @@ register({
   handler: async (env) => {
     if (!authorized(env)) return;
     if (!isOnboarded()) return startOnboarding();
-    send("Pick a project to start:", { keyboard: { inline_keyboard: [[{ text: "Pick a project", callback_data: "show:projects" }]] } });
+    requireSession();
+    send("Ready. Send text, voice, or images.\n\n/sessions — switch conversation · /new — fresh conversation");
   },
 });
 
@@ -370,7 +364,7 @@ register({
   handler: async (env) => {
     if (!authorized(env)) return;
     send([
-      "Session: /session /sessions /projects /continue /status /stop /end",
+      "Session: /new /sessions /continue /status /stop /end",
       "Settings: /model /effort /budget /plan /compact /compactwindow /worktree /mode /engine /recall /tooltrace /toolmode /verbose",
       "Identity: /whoami /link",
       "Team: /people /intros /auth (owner)",
@@ -807,7 +801,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 +812,7 @@ register({
         `Auto-replies: ${replies}`,
         `Task mode: ${modeLine}`,
         `Last notification: ${fmtTime(s.socketLastAt)}`,
+        `Last poll: ${fmtTime(s.restLastAt)}`,
       ].join("\n");
     };
 
@@ -889,23 +884,7 @@ register({
 });
 
 register({
-  name: "projects", description: "Browse all workspace projects",
-  handler: async (env) => { if (authorized(env)) send("Pick:", { keyboard: projectKeyboard() }); },
-});
-
-register({
-  name: "session", description: "Pick a project to work on", args: "[<project>]",
-  handler: async (env, { tail }) => {
-    if (!authorized(env)) return;
-    if (tail) return startSession(tail);
-    const cs = currentState().currentSession;
-    if (cs) send(`Active: ${cs.name}\n\nSwitch?`, { keyboard: projectKeyboard() });
-    else send("Pick:", { keyboard: projectKeyboard() });
-  },
-});
-
-register({
-  name: "sessions", description: "List conversations for this project",
+  name: "sessions", description: "List past conversations",
   handler: async (env) => {
     if (!authorized(env)) return;
     if (!requireSession()) return;
@@ -1451,15 +1430,13 @@ register({
 });
 
 register({
-  name: "end", description: "End current session",
+  name: "end", description: "End the current conversation",
   handler: async (env) => {
     if (!authorized(env)) return;
     const state = currentState();
-    if (state.currentSession) {
-      const result = endCurrentSession({ state });
-      if (!result.ok) return send(`Could not end session: ${result.error.message}`);
-      send(`Ended: ${result.project}`, { keyboard: { inline_keyboard: [[{ text: "New session", callback_data: "show:projects" }]] } });
-    } else send("No session.");
+    const result = endCurrentSession({ state });
+    if (!result.ok) return send(`Could not end conversation: ${result.error.message}`);
+    send("Ended. Send anything to start a fresh conversation.");
   },
 });
 
@@ -1979,7 +1956,7 @@ register({
     if (!tail) {
       const list = channelJobs();
       if (list.length === 0) {
-        return send("No crons." + archivedNote() + "\n\nAdd: /cron add \"<schedule>\" <project> \"<prompt>\"\n\nOr pick a preset:", {
+        return send("No crons." + archivedNote() + "\n\nAdd: /cron add \"<schedule>\" \"<prompt>\"\n\nOr pick a preset:", {
           keyboard: { inline_keyboard: [
             [{ text: "Standup 9am", callback_data: "cp:standup" }, { text: "Git digest 6pm", callback_data: "cp:git" }],
             [{ text: "Dep check Mon", callback_data: "cp:deps" }, { text: "Health 30min", callback_data: "cp:health" }],
@@ -1989,24 +1966,23 @@ register({
       return send("Crons:\n\n" + list.map((c, i) => `${i + 1}. ${c.label} (${c.schedule}) — ${c.project || ""}`).join("\n") + archivedNote() + "\n\nRemove: /cron remove <#>");
     }
 
-    const addMatch = tail.match(/^add\s+"(.+)"\s+(\S+)\s+"(.+)"$/);
+    const addMatch = tail.match(/^add\s+"(.+)"\s+"(.+)"$/);
     if (addMatch) {
       if (!cronLib.validate(addMatch[1])) return send("Invalid cron schedule.");
-      const proj = findProject(addMatch[2]);
-      if (!proj || Array.isArray(proj)) return send("Project not found.");
       scheduler.addJob({
         kind: "cron",
         adapter: env.adapter.id,
         adapterType: env.adapter.type,
         channelId: String(env.channelId),
         canonicalUserId: env.canonicalUserId,
-        project: proj,
-        prompt: addMatch[3],
-        label: addMatch[3].slice(0, 50),
+        project: "Workspace",
+        projectDir: WORKSPACE,
+        prompt: addMatch[2],
+        label: addMatch[2].slice(0, 50),
         source: "user",
         schedule: addMatch[1],
       });
-      return send(`Added: ${addMatch[3].slice(0, 50)} (${addMatch[1]}) for ${proj}`);
+      return send(`Added: ${addMatch[2].slice(0, 50)} (${addMatch[1]})`);
     }
 
     const removeMatch = tail.match(/^remove\s+(\d+)$/);
@@ -2018,7 +1994,7 @@ register({
       return send(`Removed: ${removed ? removed.label : "(unknown)"}`);
     }
 
-    send('Usage: /cron | /cron add "<schedule>" <project> "<prompt>" | /cron remove <#>');
+    send('Usage: /cron | /cron add "<schedule>" "<prompt>" | /cron remove <#>');
   },
 });
 

package/core/onboarding.js

@@ -89,9 +89,7 @@ You are ${data.name}'s personal AI coding assistant, running 24/7 across chat ch
   saveEnvKey("ONBOARDED", "true");
   config.ONBOARDED = "true";
 
-  send(`All set, ${data.name}! I'm configured and ready.\n\nTap /session to pick a project and start working.`, {
-    keyboard: { inline_keyboard: [[{ text: "Pick a project", callback_data: "show:projects" }]] },
-  });
+  send(`All set, ${data.name}! I'm configured and ready.\n\nSend text, voice, or images to get started. /help lists everything.`);
 }
 
 module.exports = { isOnboarded, startOnboarding, handleOnboarding, finishOnboarding };

package/core/router.js

@@ -155,7 +155,6 @@ async function onAction(envelope) {
 async function handleVoice(envelope) {
   if (isDuplicate(envelope)) return;
   const state = currentState();
-  if (!state.currentSession) return send("Pick a project first.");
   try {
     const media = envelope.media?.[0];
     if (!media) return;
@@ -190,7 +189,6 @@ async function handleVoice(envelope) {
 async function handleAudio(envelope) {
   if (isDuplicate(envelope)) return;
   const state = currentState();
-  if (!state.currentSession) return send("Pick a project first.");
   try {
     const media = envelope.media?.[0];
     if (!media) return;
@@ -214,7 +212,6 @@ async function handleAudio(envelope) {
 async function handlePhoto(envelope) {
   if (isDuplicate(envelope)) return;
   const state = currentState();
-  if (!state.currentSession) return send("Pick a project first.");
   try {
     const items = envelope.media || [];
     if (!items.length) return;
@@ -244,7 +241,6 @@ async function handlePhoto(envelope) {
 async function handleDocument(envelope) {
   if (isDuplicate(envelope)) return;
   const state = currentState();
-  if (!state.currentSession) return send("Pick a project first.");
   try {
     const media = envelope.media?.[0];
     if (!media) return;
@@ -399,11 +395,6 @@ async function handleText(envelope) {
     return;
   }
 
-  if (!state.currentSession) {
-    const { projectKeyboard } = require("./projects");
-    return send("Pick a project first:", { keyboard: projectKeyboard() });
-  }
-
   const text = envelope.text || "";
   const runContext = admitRunContext(text, state.currentSession.dir, envelope.messageId, { purpose: "foreground" });
   const attachments = [];

package/core/state.js

@@ -7,7 +7,7 @@ const path = require("path");
 const crypto = require("crypto");
 const {
   STATE_FILE, SESSIONS_FILE, IDENTITIES_FILE, CONFIG_DIR, CHAT_ID, UNIFIED_IDENTITY,
-  JOBS_FILE, CRONS_FILE,
+  JOBS_FILE, CRONS_FILE, WORKSPACE,
 } = require("./config");
 const {
   normalizeCanonicalUserId,
@@ -292,7 +292,7 @@ function migrateSavedUser(value) {
 
   const result = {
     ...source,
-    currentSession: isRecord(source.currentSession) ? { ...source.currentSession } : null,
+    currentSession: isRecord(source.currentSession) ? { ...source.currentSession } : rootSession(),
     settings,
     activeSessions,
     providerSettings,
@@ -496,6 +496,14 @@ function attachRuntimeAccessors(state) {
   return state;
 }
 
+// The bot runs at a single top-level working directory. There is no per-folder
+// project picker anymore, so every state starts already "in" the workspace
+// root and currentSession is never null — readers (cwd, transcripts, usage) can
+// rely on it being present on every channel, including the Spaces poller.
+function rootSession() {
+  return { name: "Workspace", dir: WORKSPACE || process.cwd() };
+}
+
 function createUserState(userId) {
   const saved = (savedState.users && savedState.users[userId]) || {};
   const hasSavedUser = hadPersistedStateFile
@@ -510,7 +518,7 @@ function createUserState(userId) {
   const state = {
     userId: String(userId),
     channelId: currentChannelId(),
-    currentSession: saved.currentSession || null,
+    currentSession: saved.currentSession || rootSession(),
     runningProcess: null,
     preparingRun: false,
     cancelRequested: false,
@@ -1296,6 +1304,7 @@ module.exports = {
   getActiveUsage,
   getUsageForSession,
   usageSessionKey,
+  rootSession,
   createUserState,
   getUserState,
   currentState,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.0.17",
+  "version": "3.0.19",
   "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.19 approved by Sumeet 2026-07-14 ("Rip it out"): the per-folder
+// project/session model is removed. The bot always runs at the top-level
+// workspace — currentSession defaults to { name: "Workspace", dir: WORKSPACE }
+// and is never null — which fixes Spaces (and any channel that never picked a
+// folder) replying with a dead "Pick a project first:" picker. Removed
+// /projects, /session, the project keyboard, the show:projects/s: callbacks,
+// the router's five session gates, and core/projects.js. Conversation-level
+// controls (/sessions, /new, /continue, /end) are unchanged.
+assert.strictEqual(pkg.version, "3.0.19", "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}`);
 }

package/test-provider-session-commands.js

@@ -96,7 +96,7 @@ function newEndAndContinueProbe() {
 
   const ended = handlers.endCurrentSession({ state, persist: false });
   assert.strictEqual(ended.ok, true);
-  assert.strictEqual(state.currentSession, null);
+  assert.strictEqual(state.currentSession.name, "Workspace", "ending resets to the top-level workspace, never null");
   assert.strictEqual(stateApi.getProviderSession(state, "codex", "alpha"), "codex-alpha");
   assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "claude-alpha");
   assert.strictEqual(stateApi.userOwnsProviderSession(state.userId, "alpha", "codex", "codex-alpha"), true);

package/core/projects.js

@@ -1,43 +0,0 @@
-// Workspace project utilities. Reads filesystem; no IO dependencies.
-
-const fs = require("fs");
-const path = require("path");
-const { WORKSPACE } = require("./config");
-
-function listProjects() {
-  try {
-    return fs.readdirSync(WORKSPACE, { withFileTypes: true })
-      .filter((d) => d.isDirectory())
-      .map((d) => d.name)
-      .filter((n) => !n.startsWith("."));
-  } catch (e) { return []; }
-}
-
-function findProject(query) {
-  const projects = listProjects();
-  const q = query.toLowerCase();
-  const exact = projects.find((p) => p.toLowerCase() === q);
-  if (exact) return exact;
-  const startsWith = projects.filter((p) => p.toLowerCase().startsWith(q));
-  if (startsWith.length === 1) return startsWith[0];
-  const contains = projects.filter((p) => p.toLowerCase().includes(q));
-  if (contains.length === 1) return contains[0];
-  return contains.length > 0 ? contains : null;
-}
-
-function projectKeyboard() {
-  const projects = listProjects();
-  const rows = [[{ text: "\u{1F4C1} Workspace (root)", callback_data: "s:__workspace__" }]];
-  for (let i = 0; i < projects.length; i += 2) {
-    const row = [{ text: projects[i], callback_data: `s:${projects[i]}` }];
-    if (projects[i + 1]) row.push({ text: projects[i + 1], callback_data: `s:${projects[i + 1]}` });
-    rows.push(row);
-  }
-  return { inline_keyboard: rows };
-}
-
-function workspacePath(name) {
-  return name === "__workspace__" ? WORKSPACE : path.join(WORKSPACE, name);
-}
-
-module.exports = { listProjects, findProject, projectKeyboard, workspacePath };