@ouro.bot/cli 0.1.0-alpha.37 → 0.1.0-alpha.39

package/changelog.json

@@ -1,6 +1,28 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.39",
+      "changes": [
+        "All senses now route through a shared per-turn pipeline — friend resolution, trust gate, session load, pending drain, agent turn, post-turn, and token accumulation happen in one place instead of four.",
+        "Trust gate is now channel-aware: open senses (iMessage) enforce stranger/acquaintance rules, closed senses (Teams) trust the org, local and internal always pass through.",
+        "Tool access and prompt restrictions use a single shared isTrustedLevel check — no more scattered family/friend comparisons that could drift apart.",
+        "Pending messages now inject correctly into multimodal content (image attachments no longer silently drop pending messages).",
+        "ouro reminder create supports --agent flag, matching every other identity-scoped CLI command."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.38",
+      "changes": [
+        "You now have a proper body map — understanding of your home (bundle) and bones (harness), what each directory is for, and how to modify your own configuration.",
+        "Inner dialog is now genuine internal monologue with metacognitive framing, not a second CLI session. Heartbeat and bootstrap messages read as first-person awareness.",
+        "Cross-session communication works end-to-end: inner dialog thoughts surface as [inner thought: ...] in conversations, messages to yourself route to inner dialog, and you can proactively reach out to friends via iMessage and Teams.",
+        "Tool audit: removed wrapper tools (git_commit, gh_cli, get_current_time, list_directory), added surgical tools (edit_file, glob, grep, read_file with offset/limit), consolidated 7 task tools + schedule_reminder + friend tools into ouro CLI commands.",
+        "You now understand why certain tools are restricted in certain contexts — trust level and shared channels each have independent, explained gates.",
+        "ouro friend link/unlink commands handle orphan cleanup when linking external identities, merging duplicate friend records intelligently.",
+        "During onboarding, the adoption specialist can collect phone number and Teams handle to create an initial friend record with contact info."
+      ]
+    },
     {
       "version": "0.1.0-alpha.37",
       "changes": [

package/dist/heart/daemon/daemon-cli.js

@@ -39,6 +39,7 @@ exports.discoverExistingCredentials = discoverExistingCredentials;
 exports.createDefaultOuroCliDeps = createDefaultOuroCliDeps;
 exports.runOuroCli = runOuroCli;
 const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
 const os = __importStar(require("os"));
@@ -60,6 +61,7 @@ const agent_discovery_1 = require("./agent-discovery");
 const update_hooks_1 = require("./update-hooks");
 const bundle_meta_1 = require("./hooks/bundle-meta");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
+const tasks_1 = require("../../repertoire/tasks");
 const ouro_bot_global_installer_1 = require("./ouro-bot-global-installer");
 function stringField(value) {
     return typeof value === "string" ? value : null;
@@ -224,6 +226,18 @@ async function ensureDaemonRunning(deps) {
         message: `daemon started (pid ${started.pid ?? "unknown"})`,
     };
 }
+/**
+ * Extract `--agent <name>` from an args array, returning the agent name and
+ * the remaining args with the flag pair removed.
+ */
+function extractAgentFlag(args) {
+    const idx = args.indexOf("--agent");
+    if (idx === -1 || idx + 1 >= args.length)
+        return { rest: args };
+    const agent = args[idx + 1];
+    const rest = [...args.slice(0, idx), ...args.slice(idx + 2)];
+    return { agent, rest };
+}
 function usage() {
     return [
         "Usage:",
@@ -234,6 +248,19 @@ function usage() {
         "  ouro msg --to <agent> [--session <id>] [--task <ref>] <message>",
         "  ouro poke <agent> --task <task-id>",
         "  ouro link <agent> --friend <id> --provider <provider> --external-id <external-id>",
+        "  ouro task board [<status>] [--agent <name>]",
+        "  ouro task create <title> [--type <type>] [--agent <name>]",
+        "  ouro task update <id> <status> [--agent <name>]",
+        "  ouro task show <id> [--agent <name>]",
+        "  ouro task actionable|deps|sessions [--agent <name>]",
+        "  ouro reminder create <title> --body <body> [--at <iso>] [--cadence <interval>] [--category <category>] [--agent <name>]",
+        "  ouro friend list [--agent <name>]",
+        "  ouro friend show <id> [--agent <name>]",
+        "  ouro friend create --name <name> [--trust <level>] [--agent <name>]",
+        "  ouro friend link <agent> --friend <id> --provider <p> --external-id <eid>",
+        "  ouro friend unlink <agent> --friend <id> --provider <p> --external-id <eid>",
+        "  ouro whoami [--agent <name>]",
+        "  ouro session list [--agent <name>]",
     ].join("\n");
 }
 function formatVersionOutput() {
@@ -323,7 +350,7 @@ function parsePokeCommand(args) {
         throw new Error(`Usage\n${usage()}`);
     return { kind: "task.poke", agent, taskId };
 }
-function parseLinkCommand(args) {
+function parseLinkCommand(args, kind = "friend.link") {
     const agent = args[0];
     if (!agent)
         throw new Error(`Usage\n${usage()}`);
@@ -355,7 +382,7 @@ function parseLinkCommand(args) {
         throw new Error(`Unknown identity provider '${providerRaw}'. Use aad|local|teams-conversation.`);
     }
     return {
-        kind: "friend.link",
+        kind,
         agent,
         friendId,
         provider: providerRaw,
@@ -432,6 +459,150 @@ function parseHatchCommand(args) {
         migrationPath,
     };
 }
+function parseTaskCommand(args) {
+    const { agent, rest: cleaned } = extractAgentFlag(args);
+    const [sub, ...rest] = cleaned;
+    if (!sub)
+        throw new Error(`Usage\n${usage()}`);
+    if (sub === "board") {
+        const status = rest[0];
+        return status
+            ? { kind: "task.board", status, ...(agent ? { agent } : {}) }
+            : { kind: "task.board", ...(agent ? { agent } : {}) };
+    }
+    if (sub === "create") {
+        const title = rest[0];
+        if (!title)
+            throw new Error(`Usage\n${usage()}`);
+        let type;
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i] === "--type" && rest[i + 1]) {
+                type = rest[i + 1];
+                i += 1;
+            }
+        }
+        return type
+            ? { kind: "task.create", title, type, ...(agent ? { agent } : {}) }
+            : { kind: "task.create", title, ...(agent ? { agent } : {}) };
+    }
+    if (sub === "update") {
+        const id = rest[0];
+        const status = rest[1];
+        if (!id || !status)
+            throw new Error(`Usage\n${usage()}`);
+        return { kind: "task.update", id, status, ...(agent ? { agent } : {}) };
+    }
+    if (sub === "show") {
+        const id = rest[0];
+        if (!id)
+            throw new Error(`Usage\n${usage()}`);
+        return { kind: "task.show", id, ...(agent ? { agent } : {}) };
+    }
+    if (sub === "actionable")
+        return { kind: "task.actionable", ...(agent ? { agent } : {}) };
+    if (sub === "deps")
+        return { kind: "task.deps", ...(agent ? { agent } : {}) };
+    if (sub === "sessions")
+        return { kind: "task.sessions", ...(agent ? { agent } : {}) };
+    throw new Error(`Usage\n${usage()}`);
+}
+function parseReminderCommand(args) {
+    const { agent, rest: cleaned } = extractAgentFlag(args);
+    const [sub, ...rest] = cleaned;
+    if (!sub)
+        throw new Error(`Usage\n${usage()}`);
+    if (sub === "create") {
+        const title = rest[0];
+        if (!title)
+            throw new Error(`Usage\n${usage()}`);
+        let body;
+        let scheduledAt;
+        let cadence;
+        let category;
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i] === "--body" && rest[i + 1]) {
+                body = rest[i + 1];
+                i += 1;
+            }
+            else if (rest[i] === "--at" && rest[i + 1]) {
+                scheduledAt = rest[i + 1];
+                i += 1;
+            }
+            else if (rest[i] === "--cadence" && rest[i + 1]) {
+                cadence = rest[i + 1];
+                i += 1;
+            }
+            else if (rest[i] === "--category" && rest[i + 1]) {
+                category = rest[i + 1];
+                i += 1;
+            }
+        }
+        if (!body)
+            throw new Error(`Usage\n${usage()}`);
+        if (!scheduledAt && !cadence)
+            throw new Error(`Usage\n${usage()}`);
+        return {
+            kind: "reminder.create",
+            title,
+            body,
+            ...(scheduledAt ? { scheduledAt } : {}),
+            ...(cadence ? { cadence } : {}),
+            ...(category ? { category } : {}),
+            ...(agent ? { agent } : {}),
+        };
+    }
+    throw new Error(`Usage\n${usage()}`);
+}
+function parseSessionCommand(args) {
+    const { agent, rest: cleaned } = extractAgentFlag(args);
+    const [sub] = cleaned;
+    if (!sub)
+        throw new Error(`Usage\n${usage()}`);
+    if (sub === "list")
+        return { kind: "session.list", ...(agent ? { agent } : {}) };
+    throw new Error(`Usage\n${usage()}`);
+}
+function parseFriendCommand(args) {
+    const { agent, rest: cleaned } = extractAgentFlag(args);
+    const [sub, ...rest] = cleaned;
+    if (!sub)
+        throw new Error(`Usage\n${usage()}`);
+    if (sub === "list")
+        return { kind: "friend.list", ...(agent ? { agent } : {}) };
+    if (sub === "show") {
+        const friendId = rest[0];
+        if (!friendId)
+            throw new Error(`Usage\n${usage()}`);
+        return { kind: "friend.show", friendId, ...(agent ? { agent } : {}) };
+    }
+    if (sub === "create") {
+        let name;
+        let trustLevel;
+        for (let i = 0; i < rest.length; i++) {
+            if (rest[i] === "--name" && rest[i + 1]) {
+                name = rest[i + 1];
+                i += 1;
+            }
+            else if (rest[i] === "--trust" && rest[i + 1]) {
+                trustLevel = rest[i + 1];
+                i += 1;
+            }
+        }
+        if (!name)
+            throw new Error(`Usage\n${usage()}`);
+        return {
+            kind: "friend.create",
+            name,
+            ...(trustLevel ? { trustLevel } : {}),
+            ...(agent ? { agent } : {}),
+        };
+    }
+    if (sub === "link")
+        return parseLinkCommand(rest, "friend.link");
+    if (sub === "unlink")
+        return parseLinkCommand(rest, "friend.unlink");
+    throw new Error(`Usage\n${usage()}`);
+}
 function parseOuroCommand(args) {
     const [head, second] = args;
     if (!head)
@@ -446,6 +617,18 @@ function parseOuroCommand(args) {
         return { kind: "daemon.logs" };
     if (head === "hatch")
         return parseHatchCommand(args.slice(1));
+    if (head === "task")
+        return parseTaskCommand(args.slice(1));
+    if (head === "reminder")
+        return parseReminderCommand(args.slice(1));
+    if (head === "friend")
+        return parseFriendCommand(args.slice(1));
+    if (head === "whoami") {
+        const { agent } = extractAgentFlag(args.slice(1));
+        return { kind: "whoami", ...(agent ? { agent } : {}) };
+    }
+    if (head === "session")
+        return parseSessionCommand(args.slice(1));
     if (head === "chat") {
         if (!second)
             throw new Error(`Usage\n${usage()}`);
@@ -604,32 +787,6 @@ function defaultListDiscoveredAgents() {
         readFileSync: fs.readFileSync,
     });
 }
-async function defaultLinkFriendIdentity(command) {
-    const fp = path.join((0, identity_1.getAgentBundlesRoot)(), `${command.agent}.ouro`, "friends");
-    const friendStore = new store_file_1.FileFriendStore(fp);
-    const current = await friendStore.get(command.friendId);
-    if (!current) {
-        return `friend not found: ${command.friendId}`;
-    }
-    const alreadyLinked = current.externalIds.some((ext) => ext.provider === command.provider && ext.externalId === command.externalId);
-    if (alreadyLinked) {
-        return `identity already linked: ${command.provider}:${command.externalId}`;
-    }
-    const now = new Date().toISOString();
-    await friendStore.put(command.friendId, {
-        ...current,
-        externalIds: [
-            ...current.externalIds,
-            {
-                provider: command.provider,
-                externalId: command.externalId,
-                linkedAt: now,
-            },
-        ],
-        updatedAt: now,
-    });
-    return `linked ${command.provider}:${command.externalId} to ${command.friendId}`;
-}
 function discoverExistingCredentials(secretsRoot) {
     const found = [];
     let entries;
@@ -881,7 +1038,6 @@ function createDefaultOuroCliDeps(socketPath = "/tmp/ouroboros-daemon.sock") {
         cleanupStaleSocket: defaultCleanupStaleSocket,
         fallbackPendingMessage: defaultFallbackPendingMessage,
         installSubagents: defaultInstallSubagents,
-        linkFriendIdentity: defaultLinkFriendIdentity,
         listDiscoveredAgents: defaultListDiscoveredAgents,
         runHatchFlow: hatch_flow_1.runHatchFlow,
         promptInput: defaultPromptInput,
@@ -996,6 +1152,178 @@ async function performSystemSetup(deps) {
     // Register .ouro bundle type (UTI on macOS)
     await registerOuroBundleTypeNonBlocking(deps);
 }
+function executeTaskCommand(command, taskMod) {
+    if (command.kind === "task.board") {
+        if (command.status) {
+            const lines = taskMod.boardStatus(command.status);
+            return lines.length > 0 ? lines.join("\n") : "no tasks in that status";
+        }
+        const board = taskMod.getBoard();
+        return board.full || board.compact || "no tasks found";
+    }
+    if (command.kind === "task.create") {
+        try {
+            const created = taskMod.createTask({
+                title: command.title,
+                type: command.type ?? "one-shot",
+                category: "general",
+                body: "",
+            });
+            return `created: ${created}`;
+        }
+        catch (error) {
+            return `error: ${error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error)}`;
+        }
+    }
+    if (command.kind === "task.update") {
+        const result = taskMod.updateStatus(command.id, command.status);
+        if (!result.ok) {
+            return `error: ${result.reason ?? "status update failed"}`;
+        }
+        const archivedSuffix = result.archived && result.archived.length > 0
+            ? ` | archived: ${result.archived.join(", ")}`
+            : "";
+        return `updated: ${command.id} -> ${result.to}${archivedSuffix}`;
+    }
+    if (command.kind === "task.show") {
+        const task = taskMod.getTask(command.id);
+        if (!task)
+            return `task not found: ${command.id}`;
+        return [
+            `title: ${task.title}`,
+            `type: ${task.type}`,
+            `status: ${task.status}`,
+            `category: ${task.category}`,
+            `created: ${task.created}`,
+            `updated: ${task.updated}`,
+            `path: ${task.path}`,
+            task.body ? `\n${task.body}` : "",
+        ].filter(Boolean).join("\n");
+    }
+    if (command.kind === "task.actionable") {
+        const lines = taskMod.boardAction();
+        return lines.length > 0 ? lines.join("\n") : "no action required";
+    }
+    if (command.kind === "task.deps") {
+        const lines = taskMod.boardDeps();
+        return lines.length > 0 ? lines.join("\n") : "no unresolved dependencies";
+    }
+    // command.kind === "task.sessions"
+    const lines = taskMod.boardSessions();
+    return lines.length > 0 ? lines.join("\n") : "no active sessions";
+}
+const TRUST_RANK = { family: 4, friend: 3, acquaintance: 2, stranger: 1 };
+/* v8 ignore start -- defensive: ?? fallbacks are unreachable when inputs are valid TrustLevel values @preserve */
+function higherTrust(a, b) {
+    const rankA = TRUST_RANK[a ?? "stranger"] ?? 1;
+    const rankB = TRUST_RANK[b ?? "stranger"] ?? 1;
+    return rankA >= rankB ? (a ?? "stranger") : (b ?? "stranger");
+}
+/* v8 ignore stop */
+async function executeFriendCommand(command, store) {
+    if (command.kind === "friend.list") {
+        const listAll = store.listAll;
+        if (!listAll)
+            return "friend store does not support listing";
+        const friends = await listAll.call(store);
+        if (friends.length === 0)
+            return "no friends found";
+        const lines = friends.map((f) => {
+            const trust = f.trustLevel ?? "unknown";
+            return `${f.id}  ${f.name}  ${trust}`;
+        });
+        return lines.join("\n");
+    }
+    if (command.kind === "friend.show") {
+        const record = await store.get(command.friendId);
+        if (!record)
+            return `friend not found: ${command.friendId}`;
+        return JSON.stringify(record, null, 2);
+    }
+    if (command.kind === "friend.create") {
+        const now = new Date().toISOString();
+        const id = (0, crypto_1.randomUUID)();
+        const trustLevel = (command.trustLevel ?? "acquaintance");
+        await store.put(id, {
+            id,
+            name: command.name,
+            trustLevel,
+            externalIds: [],
+            tenantMemberships: [],
+            toolPreferences: {},
+            notes: {},
+            totalTokens: 0,
+            createdAt: now,
+            updatedAt: now,
+            schemaVersion: 1,
+        });
+        return `created: ${id} (${command.name}, ${trustLevel})`;
+    }
+    if (command.kind === "friend.link") {
+        const current = await store.get(command.friendId);
+        if (!current)
+            return `friend not found: ${command.friendId}`;
+        const alreadyLinked = current.externalIds.some((ext) => ext.provider === command.provider && ext.externalId === command.externalId);
+        if (alreadyLinked)
+            return `identity already linked: ${command.provider}:${command.externalId}`;
+        const now = new Date().toISOString();
+        const newExternalIds = [
+            ...current.externalIds,
+            { provider: command.provider, externalId: command.externalId, linkedAt: now },
+        ];
+        // Orphan cleanup: check if another friend has this externalId
+        const orphan = await store.findByExternalId(command.provider, command.externalId);
+        let mergeMessage = "";
+        let mergedNotes = { ...current.notes };
+        let mergedTrust = current.trustLevel;
+        let orphanExternalIds = [];
+        if (orphan && orphan.id !== command.friendId) {
+            // Merge orphan's notes (target's notes take priority)
+            mergedNotes = { ...orphan.notes, ...current.notes };
+            // Keep higher trust level
+            mergedTrust = higherTrust(current.trustLevel, orphan.trustLevel);
+            // Collect orphan's other externalIds (excluding the one being linked)
+            orphanExternalIds = orphan.externalIds.filter((ext) => !(ext.provider === command.provider && ext.externalId === command.externalId));
+            await store.delete(orphan.id);
+            mergeMessage = ` (merged orphan ${orphan.id})`;
+        }
+        await store.put(command.friendId, {
+            ...current,
+            externalIds: [...newExternalIds, ...orphanExternalIds],
+            notes: mergedNotes,
+            trustLevel: mergedTrust,
+            updatedAt: now,
+        });
+        return `linked ${command.provider}:${command.externalId} to ${command.friendId}${mergeMessage}`;
+    }
+    // command.kind === "friend.unlink"
+    const current = await store.get(command.friendId);
+    if (!current)
+        return `friend not found: ${command.friendId}`;
+    const idx = current.externalIds.findIndex((ext) => ext.provider === command.provider && ext.externalId === command.externalId);
+    if (idx === -1)
+        return `identity not linked: ${command.provider}:${command.externalId}`;
+    const now = new Date().toISOString();
+    const filtered = current.externalIds.filter((_, i) => i !== idx);
+    await store.put(command.friendId, { ...current, externalIds: filtered, updatedAt: now });
+    return `unlinked ${command.provider}:${command.externalId} from ${command.friendId}`;
+}
+function executeReminderCommand(command, taskMod) {
+    try {
+        const created = taskMod.createTask({
+            title: command.title,
+            type: command.cadence ? "habit" : "one-shot",
+            category: command.category ?? "reminder",
+            body: command.body,
+            scheduledAt: command.scheduledAt,
+            cadence: command.cadence,
+        });
+        return `created: ${created}`;
+    }
+    catch (error) {
+        return `error: ${error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error)}`;
+    }
+}
 async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
     if (args.includes("--help") || args.includes("-h")) {
         const text = usage();
@@ -1099,9 +1427,93 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         deps.tailLogs();
         return "";
     }
-    if (command.kind === "friend.link") {
-        const linker = deps.linkFriendIdentity ?? defaultLinkFriendIdentity;
-        const message = await linker(command);
+    // ── task subcommands (local, no daemon socket needed) ──
+    if (command.kind === "task.board" || command.kind === "task.create" || command.kind === "task.update" ||
+        command.kind === "task.show" || command.kind === "task.actionable" || command.kind === "task.deps" ||
+        command.kind === "task.sessions") {
+        /* v8 ignore start -- production default: requires full identity setup @preserve */
+        const taskMod = deps.taskModule ?? (0, tasks_1.getTaskModule)();
+        /* v8 ignore stop */
+        const message = executeTaskCommand(command, taskMod);
+        deps.writeStdout(message);
+        return message;
+    }
+    // ── reminder subcommands (local, no daemon socket needed) ──
+    if (command.kind === "reminder.create") {
+        /* v8 ignore start -- production default: requires full identity setup @preserve */
+        const taskMod = deps.taskModule ?? (0, tasks_1.getTaskModule)();
+        /* v8 ignore stop */
+        const message = executeReminderCommand(command, taskMod);
+        deps.writeStdout(message);
+        return message;
+    }
+    // ── friend subcommands (local, no daemon socket needed) ──
+    if (command.kind === "friend.list" || command.kind === "friend.show" || command.kind === "friend.create" ||
+        command.kind === "friend.link" || command.kind === "friend.unlink") {
+        /* v8 ignore start -- production default: requires full identity setup @preserve */
+        let store = deps.friendStore;
+        if (!store) {
+            // Derive agent-scoped friends dir from --agent flag or link/unlink's agent field
+            const agentName = ("agent" in command && command.agent) ? command.agent : undefined;
+            const friendsDir = agentName
+                ? path.join((0, identity_1.getAgentBundlesRoot)(), `${agentName}.ouro`, "friends")
+                : path.join((0, identity_1.getAgentBundlesRoot)(), "friends");
+            store = new store_file_1.FileFriendStore(friendsDir);
+        }
+        /* v8 ignore stop */
+        const message = await executeFriendCommand(command, store);
+        deps.writeStdout(message);
+        return message;
+    }
+    // ── whoami (local, no daemon socket needed) ──
+    if (command.kind === "whoami") {
+        if (command.agent) {
+            const agentRoot = path.join((0, identity_1.getAgentBundlesRoot)(), `${command.agent}.ouro`);
+            const message = [
+                `agent: ${command.agent}`,
+                `home: ${agentRoot}`,
+                `bones: ${(0, runtime_metadata_1.getRuntimeMetadata)().version}`,
+            ].join("\n");
+            deps.writeStdout(message);
+            return message;
+        }
+        /* v8 ignore start -- production default: requires full identity setup @preserve */
+        try {
+            const info = deps.whoamiInfo
+                ? deps.whoamiInfo()
+                : {
+                    agentName: (0, identity_1.getAgentName)(),
+                    homePath: path.join((0, identity_1.getAgentBundlesRoot)(), `${(0, identity_1.getAgentName)()}.ouro`),
+                    bonesVersion: (0, runtime_metadata_1.getRuntimeMetadata)().version,
+                };
+            const message = [
+                `agent: ${info.agentName}`,
+                `home: ${info.homePath}`,
+                `bones: ${info.bonesVersion}`,
+            ].join("\n");
+            deps.writeStdout(message);
+            return message;
+        }
+        catch {
+            const message = "error: no agent context — use --agent <name> to specify";
+            deps.writeStdout(message);
+            return message;
+        }
+        /* v8 ignore stop */
+    }
+    // ── session list (local, no daemon socket needed) ──
+    if (command.kind === "session.list") {
+        /* v8 ignore start -- production default: requires full identity setup @preserve */
+        const scanner = deps.scanSessions ?? (async () => []);
+        /* v8 ignore stop */
+        const sessions = await scanner();
+        if (sessions.length === 0) {
+            const message = "no active sessions";
+            deps.writeStdout(message);
+            return message;
+        }
+        const lines = sessions.map((s) => `${s.friendId}  ${s.friendName}  ${s.channel}  ${s.lastActivity}`);
+        const message = lines.join("\n");
         deps.writeStdout(message);
         return message;
     }