@gobi-ai/cli 2.0.36 → 2.0.40

package/dist/commands/sense.js

@@ -1,129 +1,180 @@
 import { apiGet } from "../client.js";
 import { isJsonMode, jsonOut } from "./utils.js";
-export function registerSenseCommand(program) {
-    const sense = program
-        .command("sense")
-        .description("Sense commands (activities, transcriptions).");
-    // ── Activities ──
-    sense
-        .command("list-activities")
-        .description("List activity records within a time range.")
-        .requiredOption("--start-time <iso>", "Start of time range (ISO 8601 UTC, e.g. 2026-03-20T00:00:00Z)")
-        .requiredOption("--end-time <iso>", "End of time range (ISO 8601 UTC, e.g. 2026-03-20T23:59:59Z)")
+// One-liner for a transcript turn. The backend resolves speaker identities at
+// read time into `speakerLabel` (a managed-voice name, "Me", a session-stable
+// "Speaker N", or "Unknown"); fall back to the raw diarization token only if
+// it's somehow absent.
+function formatTurnLine(t) {
+    const who = t.speakerLabel || t.speaker || "Unknown";
+    return `- ${who} (${t.timestamp}): ${t.text}`;
+}
+function printTranscriptTurns(turns) {
+    const cleaned = (turns || [])
+        .map((t) => ({ ...t, text: String(t.text ?? "").trim() }))
+        .filter((t) => t.text);
+    if (!cleaned.length) {
+        console.log("No transcript available.");
+        return;
+    }
+    console.log(`Transcript (${cleaned.length} turns):\n` + cleaned.map(formatTurnLine).join("\n"));
+}
+function formatActivityLine(a) {
+    const end = a.end_time ? ` → ${a.end_time}` : " → ongoing";
+    const details = a.details ? `: ${a.details}` : "";
+    // Space activities carry the recorder(s); personal ones don't.
+    const recorders = Array.isArray(a.recorders) && a.recorders.length
+        ? `  by ${a.recorders
+            .map((r) => r.name || `user ${r.id}`)
+            .join(", ")}`
+        : "";
+    return `- [${a.id}] ${a.category ?? "activity"}${details} (${a.start_time}${end})${recorders}`;
+}
+function formatConversationLine(c) {
+    const durMs = typeof c.durationMs === "number" ? c.durationMs : null;
+    const dur = durMs != null ? ` (${Math.max(1, Math.round(durMs / 60000))}m)` : "";
+    const cat = c.category ? ` — ${c.category}` : "";
+    const status = c.status ? ` [${c.status}]` : "";
+    // Space conversations carry the recorder (whose conversation it is); personal
+    // ones don't.
+    const rec = c.recorder && typeof c.recorder === "object"
+        ? `  by ${c.recorder.name ?? "someone"}`
+        : "";
+    return `- [${c.id}] ${c.source ?? "conversation"}${status}${cat} (${c.startTime}${dur})${rec}`;
+}
+function paginationFooter(pagination) {
+    return pagination?.hasMore ? `\n  Next cursor: ${pagination.nextCursor}` : "";
+}
+// ── Activities ──
+//
+// Registers the `activities` subcommand tree under `parent` (a `gobi space` or
+// `gobi personal` group). Replaces the old top-level `gobi sense list-activities`.
+export function registerActivitiesSubcommands(parent, scope, description) {
+    const activities = parent.command("activities").description(description);
+    // ── List ──
+    activities
+        .command("list")
+        .description("List Sense activities in this scope (newest first).")
+        .option("--limit <n>", "Max items to return (default 30, max 100)")
+        .option("--before <cursor>", "Pagination cursor from a previous response (nextCursor)")
+        .option("--mine", "Only activities you recorded (space scope; no-op for personal, already yours)")
         .action(async (opts) => {
-        const params = {
-            startTime: opts.startTime,
-            endTime: opts.endTime,
-        };
-        const resp = (await apiGet("/app/activities", params));
-        const strip = ({ id, device_id, created_at, updated_at, ...rest }) => rest;
-        const allActivities = (resp.activities || []).map((a) => strip(a));
-        const lastSeenTime = resp.latestTimestamp;
-        // Pull out the last activity with null end_time as "last_activity"
-        let lastActivityIdx = -1;
-        for (let i = allActivities.length - 1; i >= 0; i--) {
-            if (allActivities[i].end_time == null) {
-                lastActivityIdx = i;
-                break;
-            }
-        }
-        const last_activity = lastActivityIdx !== -1 ? allActivities[lastActivityIdx] : undefined;
-        const activities = lastActivityIdx !== -1
-            ? allActivities.filter((_, i) => i !== lastActivityIdx)
-            : allActivities;
-        if (isJsonMode(sense)) {
-            jsonOut({ activities, last_activity, lastSeenTime });
+        const { items, pagination } = await scope.listActivities({
+            limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
+            before: opts.before,
+            mine: opts.mine,
+        });
+        if (isJsonMode(activities)) {
+            jsonOut({ activities: items, pagination: pagination ?? {} });
             return;
         }
-        if (!activities.length && !last_activity) {
+        if (!items.length) {
             console.log("No activities found.");
-            if (lastSeenTime)
-                console.log(`Latest data available: ${lastSeenTime}`);
             return;
         }
-        if (last_activity) {
-            console.log(`Last activity: [${last_activity.device_id}] ${last_activity.category}: ${last_activity.details} (${last_activity.start_time} → ongoing)`);
+        console.log(`Activities (${items.length} items, newest first):\n` +
+            items.map(formatActivityLine).join("\n") +
+            paginationFooter(pagination));
+    });
+    // ── Get (by id; scope-independent) ──
+    activities
+        .command("get <activityId>")
+        .description("Get one activity's details (visible to you if you recorded it or are a member of its space).")
+        .action(async (activityId) => {
+        const a = (await apiGet(`/app/activity/${activityId}`));
+        if (isJsonMode(activities)) {
+            jsonOut(a);
+            return;
         }
-        const lines = activities.map((a) => {
-            const endStr = a.end_time ? ` → ${a.end_time}` : "";
-            return `- [${a.device_id}] ${a.category}: ${a.details} (${a.start_time}${endStr})`;
-        });
-        if (lines.length)
-            console.log(`Activities (${activities.length} items):\n` + lines.join("\n"));
-        if (lastSeenTime)
-            console.log(`Latest data available: ${lastSeenTime}`);
+        console.log(`Activity ${a.id}\n` +
+            `  category: ${a.category ?? "(none)"}\n` +
+            (a.details ? `  details:  ${a.details}\n` : "") +
+            `  start:    ${a.start_time}\n` +
+            `  end:      ${a.end_time ?? "ongoing"}`);
+    });
+    // ── Transcript (by id; owner-only) ──
+    activities
+        .command("transcript <activityId>")
+        .description("Get an activity's transcript (owner-only; 403 for other space members).")
+        .action(async (activityId) => {
+        const resp = (await apiGet(`/app/activity/${activityId}/transcript`));
+        const turns = (resp.turns || []);
+        if (isJsonMode(activities)) {
+            jsonOut({ turns });
+            return;
+        }
+        printTranscriptTurns(turns);
     });
-    // ── Transcriptions ──
-    sense
-        .command("list-transcriptions")
-        .description("List transcription records within a time range.")
-        .requiredOption("--start-time <iso>", "Start of time range (ISO 8601 UTC, e.g. 2026-03-20T00:00:00Z)")
-        .requiredOption("--end-time <iso>", "End of time range (ISO 8601 UTC, e.g. 2026-03-20T23:59:59Z)")
+}
+// ── Conversations ──
+//
+// Registers the `conversations` subcommand tree under `parent`. The `space`
+// group lists via `/spaces/:slug/conversations` (every member's, keyset-paged);
+// the `personal` group lists via the cross-scope `/app/conversations` filtered
+// to the personal scope. Replaces the old top-level `gobi sense list-transcriptions`.
+export function registerConversationsSubcommands(parent, scope, description) {
+    const conversations = parent.command("conversations").description(description);
+    // ── List ──
+    conversations
+        .command("list")
+        .description("List conversations captured in this scope (newest first).")
+        .option("--limit <n>", "Max items to return (default 30, max 100). Ignored for personal.")
+        .option("--before <cursor>", "Pagination cursor from a previous response (nextCursor). Space scope only.")
+        .option("--mine", "Only conversations you recorded (space scope; no-op for personal, already yours)")
         .action(async (opts) => {
-        const params = {
-            startTime: opts.startTime,
-            endTime: opts.endTime,
-        };
-        const resp = (await apiGet("/app/transcriptions", params));
-        const transcriptions = (resp.transcriptions || []);
-        const lastSeenTime = resp.latestTimestamp;
-        const allTurns = [];
-        for (const t of transcriptions) {
-            const rawTurns = (t.turns || []);
-            for (const turn of rawTurns) {
-                const text = String(turn.text ?? "").trim();
-                if (!text)
-                    continue;
-                allTurns.push({
-                    speaker: String(turn.speaker ?? ""),
-                    timestamp: String(turn.timestamp ?? ""),
-                    text,
-                });
-            }
+        const { items, pagination } = await scope.listConversations({
+            limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
+            before: opts.before,
+            mine: opts.mine,
+        });
+        if (isJsonMode(conversations)) {
+            jsonOut({ conversations: items, pagination: pagination ?? {} });
+            return;
+        }
+        if (!items.length) {
+            console.log("No conversations found.");
+            return;
         }
-        // Filter to requested time range and sort by time.
-        const startMs = new Date(opts.startTime).getTime();
-        const endMs = new Date(opts.endTime).getTime();
-        const filtered = allTurns
-            .filter((t) => {
-            const ts = new Date(t.timestamp).getTime();
-            return ts >= startMs && ts <= endMs;
-        })
-            .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-        // Friendly speaker labels: named voices → their name, the user → "Me",
-        // anonymous voices (bare index, Person:/uv:) → a stable "Speaker N"
-        // numbered by first appearance across the sorted transcript.
-        const anonOrdinals = new Map();
-        let nextOrdinal = 1;
-        const labelFor = (token) => {
-            const named = token.match(/^(.+):(\d+)$/);
-            if (named) {
-                const name = named[1].trim();
-                if (name === "Me")
-                    return "Me";
-                if (name && name !== "Person" && name !== "uv")
-                    return name;
-            }
-            if (!anonOrdinals.has(token))
-                anonOrdinals.set(token, nextOrdinal++);
-            return `Speaker ${anonOrdinals.get(token)}`;
-        };
-        if (isJsonMode(sense)) {
-            jsonOut({
-                transcriptions: filtered.map((t) => ({ ...t, speaker: labelFor(t.speaker) })),
-                lastSeenTime,
-            });
+        console.log(`Conversations (${items.length} items, newest first):\n` +
+            items.map(formatConversationLine).join("\n") +
+            paginationFooter(pagination));
+    });
+    // ── Transcript (by id) ──
+    conversations
+        .command("transcript <conversationId>")
+        .description("Get a conversation's transcript and summary (owner-only).")
+        .action(async (conversationId) => {
+        const resp = (await apiGet(`/app/conversations/${conversationId}/transcript`));
+        const turns = (resp.turns || []);
+        const summary = resp.summary || null;
+        if (isJsonMode(conversations)) {
+            jsonOut(resp);
+            return;
+        }
+        if (summary && (summary.category || summary.details)) {
+            console.log(`Summary: ${summary.category ?? "(uncategorized)"}` +
+                (summary.details ? `\n  ${summary.details}` : ""));
+            console.log("");
+        }
+        if (resp.status && resp.status !== "ready") {
+            console.log(`Status: ${resp.status}`);
+        }
+        printTranscriptTurns(turns);
+    });
+    // ── Audio (by id; signed URL, owner-only) ──
+    conversations
+        .command("audio <conversationId>")
+        .description("Get a signed URL for a conversation's combined recording (owner-only; null for analyzer conversations).")
+        .action(async (conversationId) => {
+        const resp = (await apiGet(`/app/conversations/${conversationId}/audio`));
+        const url = resp.url ?? null;
+        if (isJsonMode(conversations)) {
+            jsonOut({ url });
             return;
         }
-        if (!filtered.length) {
-            console.log("No transcriptions found.");
-            if (lastSeenTime)
-                console.log(`Latest data available: ${lastSeenTime}`);
+        if (!url) {
+            console.log("No audio available for this conversation.");
             return;
         }
-        const lines = filtered.map((t) => `- ${labelFor(t.speaker)} (${t.timestamp}): ${t.text}`);
-        console.log(`Transcriptions (${filtered.length} turns):\n` + lines.join("\n"));
-        if (lastSeenTime)
-            console.log(`Latest data available: ${lastSeenTime}`);
+        console.log(url);
     });
 }

package/dist/commands/space.js

@@ -4,6 +4,7 @@ import { requireSpace, selectSpace, setSpaceRequirement, writeSpaceSetting, } fr
 import { buildMentionMap, formatAttachmentLines, formatAttachmentSummary, formatPostLabel, formatReactionChips, formatReplyLine, isJsonMode, jsonOut, postBodyText, readStdin, resolveSpaceSlug, unwrapResp, } from "./utils.js";
 import { uploadPostAttachments, assertPostAttachmentMix, } from "../attachments.js";
 import { registerArtifactSubcommands } from "./artifact.js";
+import { registerActivitiesSubcommands, registerConversationsSubcommands, } from "./sense.js";
 function readContent(value) {
     if (value === "-")
         return readStdin();
@@ -729,4 +730,38 @@ export function registerSpaceCommand(program) {
     registerArtifactSubcommands(space, { resolve: () => ({ spaceSlug: resolveSpaceSlug(space) }) }, "Versioned creations attached to posts, scoped to this space (visible to its " +
         "members). Kinds: image | video | gif | markdown | meeting_summary. Always " +
         "human-owned; revisions form a draft/published tree (one published per artifact).");
+    // ── Sense: activities + conversations (scoped to this space) ──
+    //
+    // The conversations list endpoint spans all the user's scopes (returns the caller's recent
+    // conversations across all scopes, each tagged with spaceId), so the scope
+    // resolves this space's numeric id — via GET /spaces/:slug — to filter it.
+    const senseScope = {
+        label: "space",
+        listActivities: async (params) => {
+            const q = { limit: params.limit, before: params.before };
+            if (params.mine)
+                q.mine = true;
+            const resp = (await apiGet(`/spaces/${resolveSpaceSlug(space)}/activities`, q));
+            return {
+                items: (resp.activities || []),
+                pagination: resp.pagination,
+            };
+        },
+        listConversations: async (params) => {
+            const q = { limit: params.limit, before: params.before };
+            if (params.mine)
+                q.mine = true;
+            const resp = (await apiGet(`/spaces/${resolveSpaceSlug(space)}/conversations`, q));
+            return {
+                items: (resp.conversations || []),
+                pagination: resp.pagination,
+            };
+        },
+    };
+    registerActivitiesSubcommands(space, senseScope, "This space's Sense activities — every member's, attributed to each recorder " +
+        "(browse-only). Use `gobi space --space-slug <slug> activities …` or set the " +
+        "active space with `gobi space warp`.");
+    registerConversationsSubcommands(space, senseScope, "This space's Sense conversations — every member's, attributed to each recorder " +
+        "(browse-only; transcript/audio stay owner-only). Use `gobi space --space-slug " +
+        "<slug> conversations …` or set the active space with `gobi space warp`.");
 }

package/dist/commands/update.js

@@ -28,8 +28,8 @@ function detectInstallMethod() {
         return "brew";
     }
     try {
-        const npmGlobalDir = execSync("npm root -g", { encoding: "utf-8" }).trim();
-        if (gobiBin && gobiBin.includes(npmGlobalDir.replace("/lib/node_modules", ""))) {
+        const npmRootDir = execSync("npm root -g", { encoding: "utf-8" }).trim();
+        if (gobiBin && gobiBin.includes(npmRootDir.replace("/lib/node_modules", ""))) {
             return "npm";
         }
     }

package/dist/commands/utils.js

@@ -5,7 +5,7 @@ import { getSpaceSlug, getVaultSlug } from "./init.js";
 export function readStdin() {
     return readFileSync(0, "utf8");
 }
-// The global `--json` flag lives on the root program. Walk up the ancestry so
+// The top-level `--json` flag lives on the root program. Walk up the ancestry so
 // this works regardless of how deeply the calling command is nested (e.g. a
 // leaf under `gobi space artifact …`, not just a direct child of the program).
 export function isJsonMode(cmd) {

package/dist/main.js

@@ -5,10 +5,8 @@ import { ApiError, GobiError } from "./errors.js";
 import { registerAuthCommand } from "./commands/auth.js";
 import { commandRequiresSpace, commandRequiresVault, readSettings, } from "./commands/init.js";
 import { registerSpaceCommand } from "./commands/space.js";
-import { registerGlobalCommand } from "./commands/global.js";
 import { registerPersonalCommand } from "./commands/personal.js";
 import { registerVaultCommand } from "./commands/vault.js";
-import { registerSenseCommand } from "./commands/sense.js";
 import { registerUpdateCommand } from "./commands/update.js";
 import { registerMediaCommand } from "./commands/media.js";
 const require = createRequire(import.meta.url);
@@ -57,14 +55,12 @@ export async function cli() {
     // Register all command groups
     registerAuthCommand(program);
     registerSpaceCommand(program);
-    registerGlobalCommand(program);
     registerPersonalCommand(program);
     registerVaultCommand(program);
-    registerSenseCommand(program);
     registerUpdateCommand(program);
     registerMediaCommand(program);
-    // Artifact subcommands live under `gobi space` and `gobi personal` (registered
-    // by those groups), not as a top-level `gobi artifact` group.
+    // Artifact, activities, and conversations subcommands live under `gobi space`
+    // and `gobi personal` (registered by those groups), not as top-level groups.
     // Propagate helpWidth to all subcommands
     const helpWidth = process.stdout.columns || 200;
     for (const cmd of program.commands) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gobi-ai/cli",
-  "version": "2.0.36",
+  "version": "2.0.40",
   "description": "CLI client for the Gobi collaborative knowledge platform",
   "license": "MIT",
   "type": "module",

package/skills/gobi-artifact/SKILL.md

@@ -11,12 +11,12 @@ description: >-
 allowed-tools: Bash(gobi:*)
 metadata:
   author: gobi-ai
-  version: "2.0.36"
+  version: "2.0.40"
 ---
 
 # gobi-artifact
 
-Gobi artifact commands for versioned, post-attachable creations (v2.0.36).
+Gobi artifact commands for versioned, post-attachable creations (v2.0.40).
 
 Requires gobi-cli installed and authenticated. See gobi-core skill for setup.
 
@@ -51,7 +51,7 @@ Markdown bodies can reference vault notes with `[[wikilinks]]`. Resolution again
 
 ## Important: JSON Mode
 
-For programmatic/agent usage, always pass `--json` as a **global** option (before everything else):
+For programmatic/agent usage, always pass `--json` as a **top-level** option (before everything else):
 
 ```bash
 gobi --json personal artifact list --limit 20

package/skills/gobi-artifact/references/personal.md

@@ -3,8 +3,8 @@
 ```
 Usage: gobi personal [options] [command]
 
-Personal-space commands (private posts and replies visible only to you). Mirrors the `global` subcommand shape — posts/replies live in the same data model, scoped via personalSpaceUserId so they
-never surface on the public feed.
+Personal-space commands (private posts and replies visible only to you). Posts/replies live in the same data model as space posts, scoped via personalSpaceUserId so they never surface on the public
+feed.
 
 Options:
   -h, --help                       display help for command

package/skills/gobi-core/SKILL.md

@@ -8,12 +8,12 @@ description: >-
 allowed-tools: Bash(gobi:*)
 metadata:
   author: gobi-ai
-  version: "2.0.36"
+  version: "2.0.40"
 ---
 
 # gobi-core
 
-Core CLI commands for the Gobi collaborative knowledge platform (v2.0.36).
+Core CLI commands for the Gobi collaborative knowledge platform (v2.0.40).
 
 ## Prerequisites
 
@@ -38,7 +38,6 @@ brew tap gobi-ai/tap && brew install gobi
 ## Key Concepts
 
 - **Vault**: A filetree-backed knowledge home. A local directory becomes a vault when it contains `.gobi/settings.yaml` with a `vaultSlug`. Each vault has a slug (e.g. `brave-path-zr962w`); public profile is configured by a `PUBLISH.md` document at the vault root and pushed via `gobi vault publish`.
-- **Personal Post**: A post on the author's profile that surfaces in the public global feed. Same `Post` data model as a Space Post — only the scope differs.
 - **Space Post**: A post inside a community space.
 - **Space**: A shared community knowledge area. A user can be a member of one or more spaces; each space contains posts, replies, and connected vaults.
 - **Artifact**: A versioned, human-owned creation (image, video, gif, markdown, or meeting_summary) attached to posts. Its revisions form a draft/published tree (at most one published). See the **gobi-artifact** skill.
@@ -72,19 +71,19 @@ gobi auth status
 
 | Command family | Needs vault in `.gobi`? | Needs space in `.gobi`? | Per-call override |
 |----------------|------------------------|------------------------|-------------------|
-| `auth …`, `update`, `artifact …`, `media …`, `sense …` | no | no | – |
+| `auth …`, `update`, `media …`, `personal artifact/activities/conversations …` | no | no | – |
+| `space artifact …` / `space activities …` / `space conversations …` | no | **yes** | parent `--space-slug <slug>` |
 | `vault publish` / `unpublish` / `sync` | **yes** | no | none — must run `gobi vault init` first |
 | `vault init` | no (it sets it up) | no | – |
 | `space list` / `warp [slug]` / `get [slug]` | no | no | – |
 | `space list-topics` / `feed` / `list-posts` / `get-post` / `create-post` / `edit-post` / `delete-post` / `create-reply` / `edit-reply` / `delete-reply` / `list-topic-posts` | no | **yes** | parent `--space-slug <slug>` |
-| `global feed` / `list-posts` / `get-post` / `create-post` / `edit-post` / `delete-post` / `create-reply` / `edit-reply` / `delete-reply` | no | no | – |
 | `personal feed` / `list-posts` / `get-post` / `create-post` / `edit-post` / `delete-post` / `create-reply` / `edit-reply` / `delete-reply` | no | no | – |
 
 When a command needs vault or space and neither `.gobi` nor an override flag provides it, the CLI prints a one-line warning before the command runs (e.g. `Vault not set. Run 'gobi vault init' first, or pass --vault-slug.`). The warning is suppressed under `--json`.
 
 ## Important: JSON Mode
 
-For programmatic/agent usage, always pass `--json` as a **global** option (before the subcommand) to get structured JSON output:
+For programmatic/agent usage, always pass `--json` as a **top-level** option (before the subcommand) to get structured JSON output:
 
 ```bash
 gobi --json space list

package/skills/gobi-homepage/SKILL.md

@@ -7,7 +7,7 @@ description: >-
 allowed-tools: Bash(gobi:*)
 metadata:
   author: gobi-ai
-  version: "2.0.36"
+  version: "2.0.40"
 ---
 
 # Gobi Homepage Developer Guide

package/skills/gobi-media/SKILL.md

@@ -10,18 +10,18 @@ description: >-
 allowed-tools: Bash(gobi:*)
 metadata:
   author: gobi-ai
-  version: "2.0.36"
+  version: "2.0.40"
 ---
 
 # gobi-media
 
-Gobi media generation commands (v2.0.36).
+Gobi media generation commands (v2.0.40).
 
 Requires gobi-cli installed and authenticated. See gobi-core skill for setup.
 
 ## Important: JSON Mode
 
-For programmatic/agent usage, always pass `--json` as a **global** option (before the subcommand):
+For programmatic/agent usage, always pass `--json` as a **top-level** option (before the subcommand):
 
 ```bash
 gobi --json media generate-image --prompt "a sunset over mountains"

package/skills/gobi-sense/SKILL.md

@@ -1,38 +1,88 @@
 ---
 name: gobi-sense
 description: >-
-  Gobi sense commands for activity and transcription data: list activity
-  records and list transcription records within a time range. Use when the
-  user wants to review their activities or transcriptions from Gobi Sense.
+  Gobi Sense commands for browsing activities and conversations captured by the
+  wearable and mobile app. Activities (what you were doing) and conversations
+  (phone-mic Audio Logs + detected conversations, with transcripts) are scoped
+  to a space: `gobi personal activities/conversations …` (your personal space)
+  or `gobi space activities/conversations …` (the active team space). Read-only.
+  Use when the user wants to review their Sense activities or conversations.
 allowed-tools: Bash(gobi:*)
 metadata:
   author: gobi-ai
-  version: "2.0.36"
+  version: "2.0.40"
 ---
 
 # gobi-sense
 
-Gobi sense commands for activity and transcription data (v2.0.36).
+Gobi Sense commands for browsing activities and conversations (v2.0.40).
 
 Requires gobi-cli installed and authenticated. See the **gobi-core** skill for setup.
 
-Activities and transcriptions are captured by Gobi Sense (the wearable) and the mobile app, then ingested via the cloud pipeline. The CLI surface is read-only — fetch records in a time range and feed them to whatever analysis you want to run.
+Sense data is captured by Gobi Sense (the wearable) and the mobile app, then ingested by the cloud pipeline. The CLI surface is **read-only** — list records and fetch transcripts, then feed them to whatever analysis you want to run.
+
+## Scope: personal vs space
+
+Sense data is tagged with the space it was captured in — either your **personal space** or a **team space**. The commands are the same under each scope; pick the group that matches where the data lives:
+
+- `gobi personal activities …` / `gobi personal conversations …` — your personal space (visible only to you).
+- `gobi space activities …` / `gobi space conversations …` — the active team space. The space comes from `.gobi/settings.yaml` (set with `gobi space warp <slug>`) or `gobi space --space-slug <slug> activities …`.
+
+The examples below use `personal`; swap in `space` to browse a team space.
+
+## Activities vs conversations
+
+- **activities** — a running log of what you were doing (category + details), each with a start/end time. In a team space, every member's activities show up, attributed to their recorder. Transcripts are owner-only.
+- **conversations** — phone-mic Audio Log recordings plus Sense-detected conversations, each with a transcript and an auto-generated summary. In a team space, every member's conversations show up, attributed to their recorder (the transcript and `audio` signed URL stay owner-only). In your personal space, you see your own.
+
+The old `gobi sense list-activities` / `gobi sense list-transcriptions` commands are gone — transcriptions were unified into **conversations**, and both concepts are now space-scoped.
 
 ## Important: JSON Mode
 
-For programmatic/agent usage, always pass `--json` as a **global** option (before the subcommand):
+For programmatic/agent usage, always pass `--json` as a **top-level** option (before the subcommand):
 
 ```bash
-gobi --json sense list-activities --start-time 2026-04-01T00:00:00Z --end-time 2026-04-08T00:00:00Z
+gobi --json personal activities list --limit 30
+gobi --json personal conversations list
+gobi --json space --space-slug my-team activities transcript 978
 ```
 
-Times are ISO 8601 UTC.
+JSON mode wraps the response as `{"success": true, "data": <…>}` (or `{"success": false, "error": "…"}`).
+
+## Typical workflow
+
+List recent activities (newest first, paged with `--limit` / `--before`), then pull one's transcript:
+
+```bash
+gobi --json personal activities list --limit 30
+gobi --json personal activities get 978
+gobi --json personal activities transcript 978
+```
+
+List recent conversations in a space, then read a transcript (with its summary) or grab the recording:
+
+```bash
+gobi --json space --space-slug my-team conversations list
+gobi --json space --space-slug my-team conversations transcript 12345
+gobi --json space --space-slug my-team conversations audio 12345
+```
+
+Both list commands are newest-first and page with `--limit` / `--before` (pass a previous response's `nextCursor` to `--before`). Scope difference: **`gobi space … activities/conversations list`** is a complete, fully-paginated per-space history (every member's records). **`gobi personal … conversations list`** is filtered from the cross-scope conversations feed, so it shows your recent personal conversations rather than a fully paginated history (`gobi personal activities list` is fully paginated).
 
 ## Available Commands
 
-- `gobi sense list-activities` — List activity records within a time range.
-- `gobi sense list-transcriptions` — List transcription records within a time range.
+Under `gobi personal …` (personal space) or `gobi space …` (active team space):
+
+- `activities list` — List Sense activities in this scope (`--limit`, `--before`, `--mine`).
+- `activities get <activityId>` — Get one activity's details.
+- `activities transcript <activityId>` — Get an activity's transcript (owner-only).
+- `conversations list` — List conversations captured in this scope, newest first (`--limit`, `--before`, `--mine`). In a space, every member's (attributed to each recorder).
+- `conversations transcript <conversationId>` — Get a conversation's transcript and summary.
+- `conversations audio <conversationId>` — Get a signed URL for the recording (owner-only).
+
+All commands are read-only. In a space, `--mine` on either `list` restricts it to records **you** recorded (`user_id = you`); it's a no-op in the personal lane, which is already all yours.
 
 ## Reference Documentation
 
-- [gobi sense](references/sense.md)
+- [gobi personal](references/personal.md)
+- [gobi space](references/space.md)