memorix 1.2.1 → 1.2.3

package/src/cli/commands/handoff.ts

@@ -1,7 +1,7 @@
 import { defineCommand } from 'citty';
 import { storeObservation } from '../../memory/observations.js';
 import { createHandoffArtifact } from '../../team/handoff.js';
-import { emitError, emitResult, getCliProjectContext, parseCsvList, shortId } from './operator-shared.js';
+import { emitError, emitResult, getCliProjectContext, parseCsvList, resolveCliActorId, shortId } from './operator-shared.js';
 
 export default defineCommand({
   meta: {
@@ -23,19 +23,33 @@ export default defineCommand({
     const asJson = !!args.json;
 
     try {
-      const { project, teamStore } = await getCliProjectContext();
+      const { project, teamStore, identity } = await getCliProjectContext();
+      const fromAgentId = resolveCliActorId(args.fromAgentId, identity, 'fromAgentId');
 
       switch (action) {
         case 'send': {
-          if (!args.fromAgentId || !args.summary || !args.context) {
-            emitError('fromAgentId, summary, and context are required for "memorix handoff send"', asJson);
+          if (!fromAgentId || !args.summary || !args.context) {
+            emitError('summary, context, and an active CLI identity or fromAgentId are required for "memorix handoff send"', asJson);
             return;
           }
+          const sender = teamStore.getAgent(fromAgentId);
+          if (!sender || sender.project_id !== project.id || sender.status !== 'active') {
+            emitError('The handoff sender must be an active coordination member of this project.', asJson);
+            return;
+          }
+          const toAgentId = (args.toAgentId as string | undefined)?.trim();
+          if (toAgentId) {
+            const recipient = teamStore.getAgent(toAgentId);
+            if (!recipient || recipient.project_id !== project.id || recipient.status !== 'active') {
+              emitError('The handoff recipient must be an active coordination member of this project.', asJson);
+              return;
+            }
+          }
           const result = await createHandoffArtifact(
             {
               projectId: project.id,
-              fromAgentId: args.fromAgentId as string,
-              toAgentId: args.toAgentId as string | undefined,
+              fromAgentId,
+              toAgentId,
               taskId: args.taskId as string | undefined,
               summary: args.summary as string,
               context: args.context as string,
@@ -57,7 +71,7 @@ export default defineCommand({
           console.log('Memorix Handoff Commands');
           console.log('');
           console.log('Usage:');
-          console.log('  memorix handoff send --fromAgentId <id> --summary "..." --context "..." [--toAgentId <id>] [--taskId <id>]');
+          console.log('  memorix handoff send --summary "..." --context "..." [--fromAgentId <id>] [--toAgentId <id>] [--taskId <id>]');
       }
     } catch (error) {
       emitError(error instanceof Error ? error.message : String(error), asJson);

package/src/cli/commands/identity.ts

@@ -0,0 +1,116 @@
+import { defineCommand } from 'citty';
+import { AGENT_TYPE_ROLE_MAP } from '../../team/team-store.js';
+import { clearCliIdentity, loadCliIdentity, saveCliIdentity } from '../identity.js';
+import { emitError, emitResult, getCliProjectContext, parseCsvList } from './operator-shared.js';
+
+function requiredText(value: unknown, label: string): string {
+  const text = typeof value === 'string' ? value.trim() : '';
+  if (!text) throw new Error(`${label} is required`);
+  return text;
+}
+
+export default defineCommand({
+  meta: {
+    name: 'identity',
+    description: 'Select the explicit CLI actor used for private or team-scoped operations',
+  },
+  args: {
+    agentId: { type: 'string', description: 'Existing active coordination agent ID' },
+    agentType: { type: 'string', description: 'Agent type when joining (for example codex)' },
+    instanceId: { type: 'string', description: 'Stable instance identity when joining' },
+    name: { type: 'string', description: 'Optional display name when joining' },
+    role: { type: 'string', description: 'Optional coordination role when joining' },
+    capabilities: { type: 'string', description: 'Comma-separated capability list when joining' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = ((args._ as string[])?.[0] || 'status').toLowerCase();
+    const asJson = !!args.json;
+
+    try {
+      const { project, dataDir, teamStore, identity, reader, identityWarning } = await getCliProjectContext();
+
+      switch (action) {
+        case 'status': {
+          const saved = await loadCliIdentity(dataDir, project.id);
+          const agent = saved ? teamStore.getAgent(saved.agentId) : undefined;
+          emitResult(
+            {
+              project,
+              identity,
+              savedIdentity: saved,
+              agent: agent ?? null,
+              reader,
+              ...(identityWarning ? { warning: identityWarning } : {}),
+            },
+            identity
+              ? `CLI identity: ${agent?.name ?? identity.agentId} (${identity.agentId})`
+              : identityWarning ?? 'CLI identity: project-scoped only. Use "memorix identity join" or "memorix identity use --agent-id <id>" for private/team operations.',
+            asJson,
+          );
+          return;
+        }
+
+        case 'join': {
+          const agentType = requiredText(args.agentType, 'agentType');
+          const agent = teamStore.registerAgent({
+            projectId: project.id,
+            agentType,
+            instanceId: args.instanceId as string | undefined,
+            name: args.name as string | undefined,
+            role: (args.role as string | undefined) || AGENT_TYPE_ROLE_MAP[agentType] || 'engineer',
+            capabilities: parseCsvList(args.capabilities as string | undefined),
+          });
+          const nextIdentity = {
+            agentId: agent.agent_id,
+            projectId: project.id,
+            activatedAt: new Date().toISOString(),
+          };
+          await saveCliIdentity(dataDir, nextIdentity);
+          emitResult(
+            { project, identity: nextIdentity, agent },
+            `CLI identity activated: ${agent.name} (${agent.agent_id})`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'use': {
+          const agentId = requiredText(args.agentId, 'agentId');
+          const agent = teamStore.getAgent(agentId);
+          if (!agent || agent.project_id !== project.id || agent.status !== 'active') {
+            emitError('agentId must identify an active coordination member of this project.', asJson);
+            return;
+          }
+          const nextIdentity = {
+            agentId: agent.agent_id,
+            projectId: project.id,
+            activatedAt: new Date().toISOString(),
+          };
+          await saveCliIdentity(dataDir, nextIdentity);
+          emitResult(
+            { project, identity: nextIdentity, agent },
+            `CLI identity activated: ${agent.name} (${agent.agent_id})`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'clear': {
+          await clearCliIdentity(dataDir);
+          emitResult(
+            { project, cleared: true },
+            'CLI identity cleared. Subsequent commands use project-scoped access only.',
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          emitError(`unknown identity action "${action}". Use "status", "join", "use", or "clear".`, asJson);
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});

package/src/cli/commands/ingest-image.ts

@@ -3,7 +3,7 @@ import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { analyzeImage } from '../../multimodal/image-loader.js';
 import { storeObservation } from '../../memory/observations.js';
-import { emitError, emitResult, getCliProjectContext } from './operator-shared.js';
+import { emitError, emitResult, getCliProjectContext, resolveCliWriteScope } from './operator-shared.js';
 
 function inferMimeType(filePath: string): string {
   const ext = path.extname(filePath).toLowerCase();
@@ -29,6 +29,7 @@ export default defineCommand({
     path: { type: 'string', description: 'Path to the image file' },
     prompt: { type: 'string', description: 'Custom analysis prompt' },
     mimeType: { type: 'string', description: 'Explicit MIME type override' },
+    visibility: { type: 'string', description: 'Memory visibility: project (default), personal, or team' },
     json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
   },
   run: async ({ args }) => {
@@ -39,8 +40,8 @@ export default defineCommand({
         emitError('path is required for "memorix ingest image"', asJson);
         return;
       }
-      const { project } = await getCliProjectContext();
-      const resolvedPath = path.resolve(process.cwd(), imagePath);
+      const { project, reader, identity } = await getCliProjectContext();
+      const resolvedPath = path.resolve(project.rootPath, imagePath);
       const base64 = readFileSync(resolvedPath).toString('base64');
       const filename = path.basename(resolvedPath);
       const analysis = await analyzeImage({
@@ -59,6 +60,7 @@ export default defineCommand({
         facts: analysis.entities,
         projectId: project.id,
         source: 'manual',
+        ...resolveCliWriteScope({ reader, identity }, args.visibility as string | undefined),
       });
 
       emitResult(

package/src/cli/commands/lock.ts

@@ -1,5 +1,5 @@
 import { defineCommand } from 'citty';
-import { emitError, emitResult, getCliProjectContext, shortId } from './operator-shared.js';
+import { emitError, emitResult, getCliProjectContext, resolveCliActorId, shortId } from './operator-shared.js';
 
 export default defineCommand({
   meta: {
@@ -16,21 +16,22 @@ export default defineCommand({
     const asJson = !!args.json;
 
     try {
-      const { project, teamStore } = await getCliProjectContext();
+      const { project, teamStore, identity } = await getCliProjectContext();
+      const agentId = resolveCliActorId(args.agentId, identity);
 
       switch (action) {
         case 'lock': {
-          if (!args.file || !args.agentId) {
-            emitError('file and agentId are required for "memorix lock lock"', asJson);
+          if (!args.file || !agentId) {
+            emitError('file and an active CLI identity or agentId are required for "memorix lock lock"', asJson);
             return;
           }
-          const result = teamStore.acquireLock(project.id, args.file as string, args.agentId as string);
+          const result = teamStore.acquireLock(project.id, args.file as string, agentId);
           if (!result.success) {
             emitError(`File is already locked by ${shortId(result.lockedBy)}`, asJson);
             return;
           }
           emitResult(
-            { project, file: args.file, lockedBy: args.agentId },
+            { project, file: args.file, lockedBy: agentId },
             `Locked: ${args.file as string}`,
             asJson,
           );
@@ -38,11 +39,11 @@ export default defineCommand({
         }
 
         case 'unlock': {
-          if (!args.file || !args.agentId) {
-            emitError('file and agentId are required for "memorix lock unlock"', asJson);
+          if (!args.file || !agentId) {
+            emitError('file and an active CLI identity or agentId are required for "memorix lock unlock"', asJson);
             return;
           }
-          const released = teamStore.releaseLock(project.id, args.file as string, args.agentId as string);
+          const released = teamStore.releaseLock(project.id, args.file as string, agentId);
           if (!released) {
             emitError('Cannot unlock: not the owner or the file is not locked', asJson);
             return;
@@ -68,7 +69,7 @@ export default defineCommand({
             return;
           }
 
-          const locks = teamStore.listLocks(project.id, args.agentId as string | undefined);
+          const locks = teamStore.listLocks(project.id, agentId);
           emitResult(
             { project, locks },
             locks.length === 0

package/src/cli/commands/memory.ts

@@ -1,9 +1,19 @@
 import { defineCommand } from 'citty';
 import { compactDetail, compactSearch, compactTimeline } from '../../compact/engine.js';
 import { withFreshIndex } from '../../memory/freshness.js';
-import { getAllObservations, getProjectObservations, resolveObservations, storeObservation, suggestTopicKey } from '../../memory/observations.js';
+import { getAllObservations, getObservation, getProjectObservations, resolveObservations, storeObservation, suggestTopicKey } from '../../memory/observations.js';
 import { buildGraphContextPacket, formatGraphContextPrompt } from '../../memory/graph-context.js';
-import { emitError, emitResult, getCliProjectContext, parseCsvList, parsePositiveInt, coerceObservationStatus, coerceObservationType } from './operator-shared.js';
+import { canManageObservation, filterReadableObservations, resolveObservationVisibility } from '../../memory/visibility.js';
+import {
+  coerceObservationStatus,
+  coerceObservationType,
+  emitError,
+  emitResult,
+  getCliProjectContext,
+  parseCsvList,
+  parsePositiveInt,
+  resolveCliWriteScope,
+} from './operator-shared.js';
 
 export default defineCommand({
   meta: {
@@ -19,6 +29,7 @@ export default defineCommand({
     facts: { type: 'string', description: 'Comma-separated facts' },
     files: { type: 'string', description: 'Comma-separated file list' },
     concepts: { type: 'string', description: 'Comma-separated concept list' },
+    visibility: { type: 'string', description: 'Memory visibility: project (default), personal, or team' },
     ids: { type: 'string', description: 'Comma-separated observation IDs' },
     id: { type: 'string', description: 'Single observation ID' },
     status: { type: 'string', description: 'Resolved or archived' },
@@ -32,6 +43,7 @@ export default defineCommand({
     after: { type: 'string', description: 'Timeline depth after anchor' },
     threshold: { type: 'string', description: 'Similarity threshold for consolidate' },
     dryRun: { type: 'boolean', description: 'Preview changes without mutating data' },
+    'dry-run': { type: 'boolean', description: 'Kebab-case alias for --dryRun' },
     trigger: { type: 'string', description: 'Custom trigger text for promoted mini-skills' },
     instruction: { type: 'string', description: 'Custom instruction for promoted mini-skills' },
     tags: { type: 'string', description: 'Comma-separated extra tags for promoted mini-skills' },
@@ -44,7 +56,7 @@ export default defineCommand({
     const asJson = !!args.json;
 
     try {
-      const { project } = await getCliProjectContext({ searchIndex: true });
+      const { project, dataDir, reader, identity } = await getCliProjectContext({ searchIndex: true });
 
       switch (action) {
         case 'search': {
@@ -54,7 +66,7 @@ export default defineCommand({
             return;
           }
           const limit = parsePositiveInt(args.limit as string | undefined, 10);
-          const result = await compactSearch({ query, limit, projectId: project.id });
+          const result = await compactSearch({ query, limit, projectId: project.id, reader });
           emitResult({ project, entries: result.entries }, result.formatted, asJson);
           return;
         }
@@ -67,7 +79,7 @@ export default defineCommand({
             emitError('query is required for "memorix memory graph-context"', asJson);
             return;
           }
-          const observations = getAllObservations();
+          const observations = filterReadableObservations(getAllObservations(), reader);
           const packet = buildGraphContextPacket(observations, {
             projectId: project.id,
             query,
@@ -92,7 +104,7 @@ export default defineCommand({
 
         case 'recent': {
           const limit = parsePositiveInt(args.limit as string | undefined, 10);
-          const observations = getProjectObservations(project.id)
+          const observations = filterReadableObservations(getProjectObservations(project.id), reader)
             .filter((obs) => (obs.status ?? 'active') === 'active')
             .slice(-limit)
             .reverse();
@@ -118,6 +130,10 @@ export default defineCommand({
             (args.topicKey as string | undefined)?.trim() ||
             suggestTopicKey(type, title) ||
             undefined;
+          const writeScope = resolveCliWriteScope(
+            { reader, identity },
+            args.visibility as string | undefined,
+          );
           const result = await storeObservation({
             entityName: (args.entity as string | undefined)?.trim() || 'general',
             type,
@@ -129,6 +145,7 @@ export default defineCommand({
             projectId: project.id,
             topicKey,
             source: 'manual',
+            ...writeScope,
           });
           emitResult(
             { project, observation: result.observation, upserted: result.upserted },
@@ -166,7 +183,7 @@ export default defineCommand({
               ? `obs:${numericId}@${project.id}`
               : ref;
           });
-          const result = await compactDetail(scopedRefs);
+          const result = await compactDetail(scopedRefs, { reader });
           emitResult({ project, documents: result.documents }, result.formatted, asJson);
           return;
         }
@@ -182,6 +199,7 @@ export default defineCommand({
             project.id,
             parsePositiveInt(args.before as string | undefined, 3),
             parsePositiveInt(args.after as string | undefined, 3),
+            reader,
           );
           emitResult({ project, timeline: result.timeline }, result.formatted, asJson);
           return;
@@ -196,7 +214,15 @@ export default defineCommand({
             return;
           }
           const status = coerceObservationStatus(args.status as string | undefined);
-          const result = await resolveObservations(ids, status);
+          const authorizedIds = ids.filter((id) => {
+            const observation = getObservation(id, project.id);
+            return observation ? canManageObservation(observation, reader) : false;
+          });
+          if (authorizedIds.length === 0) {
+            emitError('No requested observations are manageable with the active CLI scope.', asJson);
+            return;
+          }
+          const result = await resolveObservations(authorizedIds, status);
           emitResult(
             { project, result, status },
             `Resolved ${result.resolved.length} observation(s) to ${status}${result.notFound.length > 0 ? `; not found: ${result.notFound.join(', ')}` : ''}`,
@@ -207,7 +233,7 @@ export default defineCommand({
 
         case 'deduplicate': {
           const query = (args.query as string | undefined)?.trim();
-          const dryRun = !!args.dryRun;
+          const dryRun = !!args.dryRun || !!args['dry-run'];
           const { isLLMEnabled } = await import('../../llm/provider.js');
           if (!isLLMEnabled()) {
             emitResult(
@@ -220,7 +246,10 @@ export default defineCommand({
 
           const { deduplicateMemory } = await import('../../llm/memory-manager.js');
           const allObs = await withFreshIndex(() =>
-            getAllObservations().filter((obs) => (obs.status ?? 'active') === 'active' && obs.projectId === project.id),
+            filterReadableObservations(
+              getAllObservations().filter((obs) => (obs.status ?? 'active') === 'active' && obs.projectId === project.id),
+              reader,
+            ),
           );
 
           if (allObs.length < 2) {
@@ -230,7 +259,7 @@ export default defineCommand({
 
           let candidates = allObs;
           if (query) {
-            const searchResult = await compactSearch({ query, limit: 20, projectId: project.id, status: 'active' });
+            const searchResult = await compactSearch({ query, limit: 20, projectId: project.id, status: 'active', reader });
             const ids = new Set(searchResult.entries.map((entry) => entry.id));
             candidates = allObs.filter((obs) => ids.has(obs.id));
           } else {
@@ -277,7 +306,13 @@ export default defineCommand({
             return;
           }
 
-          const result = await resolveObservations([...new Set(toResolve)], 'resolved');
+          const result = await resolveObservations(
+            [...new Set(toResolve)].filter((id) => {
+              const observation = getObservation(id, project.id);
+              return observation ? canManageObservation(observation, reader) : false;
+            }),
+            'resolved',
+          );
           emitResult(
             { project, actions, resolved: result.resolved, notFound: result.notFound, dryRun: false },
             `Resolved ${result.resolved.length} duplicate observation(s).`,
@@ -292,7 +327,7 @@ export default defineCommand({
           const { findConsolidationCandidates, executeConsolidation } = await import('../../memory/consolidation.js');
 
           if (consolidationAction === 'preview') {
-            const clusters = await findConsolidationCandidates(process.cwd(), project.id, { threshold });
+            const clusters = await findConsolidationCandidates(project.rootPath, project.id, { threshold });
             emitResult(
               { project, clusters, action: consolidationAction },
               clusters.length === 0
@@ -306,7 +341,7 @@ export default defineCommand({
           }
 
           if (consolidationAction === 'execute') {
-            const result = await executeConsolidation(process.cwd(), project.id, { threshold });
+            const result = await executeConsolidation(project.rootPath, project.id, { threshold });
             emitResult(
               { project, action: consolidationAction, ...result },
               result.clustersFound === 0
@@ -325,11 +360,10 @@ export default defineCommand({
           const promoteAction = (args.action as string | undefined) || 'promote';
           const { promoteToMiniSkill, loadAllMiniSkills, deleteMiniSkill } = await import('../../skills/mini-skills.js');
           const { initMiniSkillStore } = await import('../../store/mini-skill-store.js');
-          const { dataDir } = await getCliProjectContext();
           await initMiniSkillStore(dataDir);
 
           if (promoteAction === 'list') {
-            const skills = await loadAllMiniSkills(process.cwd());
+            const skills = await loadAllMiniSkills(project.rootPath);
             emitResult(
               { project, skills, action: promoteAction },
               skills.length === 0 ? 'No mini-skills found.' : skills.map((skill) => `- #${skill.id} ${skill.title}`).join('\n'),
@@ -344,7 +378,7 @@ export default defineCommand({
               emitError('skillId is required for "memorix memory promote --action delete"', asJson);
               return;
             }
-            const deleted = await deleteMiniSkill(process.cwd(), skillId);
+            const deleted = await deleteMiniSkill(project.rootPath, skillId);
             if (!deleted) {
               emitError(`Mini-skill #${skillId} not found`, asJson);
               return;
@@ -361,12 +395,15 @@ export default defineCommand({
             return;
           }
           const observations = await withFreshIndex(() => getAllObservations());
-          const matched = observations.filter((obs) => ids.includes(obs.id));
+          const matched = filterReadableObservations(
+            observations.filter((obs) => obs.projectId === project.id && ids.includes(obs.id)),
+            reader,
+          ).filter((observation) => resolveObservationVisibility(observation) === 'project');
           if (matched.length === 0) {
-            emitError(`No observations found for IDs: ${ids.join(', ')}`, asJson);
+            emitError(`No project-visible observations found for IDs: ${ids.join(', ')}. Private and team records cannot be promoted into shared skills.`, asJson);
             return;
           }
-          const skill = await promoteToMiniSkill(process.cwd(), project.id, matched, {
+          const skill = await promoteToMiniSkill(project.rootPath, project.id, matched, {
             trigger: args.trigger as string | undefined,
             instruction: args.instruction as string | undefined,
             tags: parseCsvList(args.tags as string | undefined),
@@ -385,7 +422,7 @@ export default defineCommand({
           console.log('Usage:');
           console.log('  memorix memory search --query "timeout bug" [--limit 10]');
           console.log('  memorix memory recent [--limit 10]');
-          console.log('  memorix memory store --text "..." [--title "..."] [--type discovery]');
+          console.log('  memorix memory store --text "..." [--title "..."] [--type discovery] [--visibility project|personal|team]');
           console.log('  memorix memory suggest-topic-key --type decision --title "..."');
           console.log('  memorix memory detail --id 42');
           console.log('  memorix memory detail obs:42@org/project');

package/src/cli/commands/message.ts

@@ -1,5 +1,5 @@
 import { defineCommand } from 'citty';
-import { emitError, emitResult, getCliProjectContext, shortId } from './operator-shared.js';
+import { emitError, emitResult, getCliProjectContext, resolveCliActorId, shortId } from './operator-shared.js';
 
 export default defineCommand({
   meta: {
@@ -22,12 +22,18 @@ export default defineCommand({
     const asJson = !!args.json;
 
     try {
-      const { project, teamStore } = await getCliProjectContext();
+      const { project, teamStore, identity } = await getCliProjectContext();
+      const senderAgentId = resolveCliActorId(args.from, identity, 'from');
+      const inboxAgentId = resolveCliActorId(
+        (args.agentId as string | undefined) ?? (args.from as string | undefined),
+        identity,
+        'agentId',
+      );
 
       switch (action) {
         case 'send': {
-          if (!args.from || !args.type || !args.content) {
-            emitError('from, type, and content are required for "memorix message send"', asJson);
+          if (!senderAgentId || !args.type || !args.content) {
+            emitError('type, content, and an active CLI identity or from agentId are required for "memorix message send"', asJson);
             return;
           }
           if (!args.to && !args.toRole) {
@@ -36,7 +42,7 @@ export default defineCommand({
           }
           const message = teamStore.sendMessage({
             projectId: project.id,
-            senderAgentId: args.from as string,
+            senderAgentId,
             recipientAgentId: (args.to as string | undefined) ?? null,
             type: args.type as string,
             content: args.content as string,
@@ -58,13 +64,13 @@ export default defineCommand({
         }
 
         case 'broadcast': {
-          if (!args.from || !args.type || !args.content) {
-            emitError('from, type, and content are required for "memorix message broadcast"', asJson);
+          if (!senderAgentId || !args.type || !args.content) {
+            emitError('type, content, and an active CLI identity or from agentId are required for "memorix message broadcast"', asJson);
             return;
           }
           const message = teamStore.sendMessage({
             projectId: project.id,
-            senderAgentId: args.from as string,
+            senderAgentId,
             recipientAgentId: null,
             type: args.type as string,
             content: args.content as string,
@@ -82,15 +88,14 @@ export default defineCommand({
         }
 
         case 'inbox': {
-          const agentId = (args.agentId as string | undefined) || (args.from as string | undefined);
-          if (!agentId) {
-            emitError('agentId is required for "memorix message inbox"', asJson);
+          if (!inboxAgentId) {
+            emitError('an active CLI identity or agentId is required for "memorix message inbox"', asJson);
             return;
           }
-          const messages = teamStore.getInbox(project.id, agentId);
-          const unreadCount = teamStore.getUnreadCount(project.id, agentId);
+          const messages = teamStore.getInbox(project.id, inboxAgentId);
+          const unreadCount = teamStore.getUnreadCount(project.id, inboxAgentId);
           if (args.markRead) {
-            teamStore.markAllRead(project.id, agentId);
+            teamStore.markAllRead(project.id, inboxAgentId);
           }
           emitResult(
             { project, unreadCount, messages },