memorix 1.6.1 → 1.6.3

package/src/cli/commands/lock.ts

@@ -1,97 +1,97 @@
-import { defineCommand } from 'citty';
+import { defineCommand } from 'citty';
 import { emitError, emitResult, getCliProjectContext, resolveCliActorId, shortId } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'lock',
-    description: 'Acquire, release, and inspect advisory team file locks',
-  },
-  args: {
-    file: { type: 'string', description: 'File path to lock or inspect' },
-    agentId: { type: 'string', description: 'Agent ID acquiring or releasing the lock' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
+
+export default defineCommand({
+  meta: {
+    name: 'lock',
+    description: 'Acquire, release, and inspect advisory team file locks',
+  },
+  args: {
+    file: { type: 'string', description: 'File path to lock or inspect' },
+    agentId: { type: 'string', description: 'Agent ID acquiring or releasing the lock' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    const asJson = !!args.json;
+
+    try {
       const { project, teamStore, identity } = await getCliProjectContext();
       const agentId = resolveCliActorId(args.agentId, identity);
-
-      switch (action) {
-        case 'lock': {
+
+      switch (action) {
+        case 'lock': {
           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, agentId);
-          if (!result.success) {
-            emitError(`File is already locked by ${shortId(result.lockedBy)}`, asJson);
-            return;
-          }
-          emitResult(
+          if (!result.success) {
+            emitError(`File is already locked by ${shortId(result.lockedBy)}`, asJson);
+            return;
+          }
+          emitResult(
             { project, file: args.file, lockedBy: agentId },
-            `Locked: ${args.file as string}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'unlock': {
+            `Locked: ${args.file as string}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'unlock': {
           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, agentId);
-          if (!released) {
-            emitError('Cannot unlock: not the owner or the file is not locked', asJson);
-            return;
-          }
-          emitResult(
-            { project, file: args.file, released: true },
-            `Unlocked: ${args.file as string}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'status': {
-          if (args.file) {
-            const lock = teamStore.getLockStatus(project.id, args.file as string);
-            emitResult(
-              { project, lock },
-              lock
-                ? `Locked by ${teamStore.getAgent(lock.locked_by)?.name ?? shortId(lock.locked_by)}: ${args.file as string}`
-                : `Unlocked: ${args.file as string}`,
-              asJson,
-            );
-            return;
-          }
-
+          if (!released) {
+            emitError('Cannot unlock: not the owner or the file is not locked', asJson);
+            return;
+          }
+          emitResult(
+            { project, file: args.file, released: true },
+            `Unlocked: ${args.file as string}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'status': {
+          if (args.file) {
+            const lock = teamStore.getLockStatus(project.id, args.file as string);
+            emitResult(
+              { project, lock },
+              lock
+                ? `Locked by ${teamStore.getAgent(lock.locked_by)?.name ?? shortId(lock.locked_by)}: ${args.file as string}`
+                : `Unlocked: ${args.file as string}`,
+              asJson,
+            );
+            return;
+          }
+
           const locks = teamStore.listLocks(project.id, agentId);
-          emitResult(
-            { project, locks },
-            locks.length === 0
-              ? 'No active file locks.'
-              : locks
-                  .map((lock) => `- ${lock.file} -> ${teamStore.getAgent(lock.locked_by)?.name ?? shortId(lock.locked_by)}`)
-                  .join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Lock Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix lock lock --file src/app.ts --agentId <id>');
-          console.log('  memorix lock unlock --file src/app.ts --agentId <id>');
-          console.log('  memorix lock status [--file src/app.ts] [--agentId <id>]');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
+          emitResult(
+            { project, locks },
+            locks.length === 0
+              ? 'No active file locks.'
+              : locks
+                  .map((lock) => `- ${lock.file} -> ${teamStore.getAgent(lock.locked_by)?.name ?? shortId(lock.locked_by)}`)
+                  .join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Lock Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix lock lock --file src/app.ts --agentId <id>');
+          console.log('  memorix lock unlock --file src/app.ts --agentId <id>');
+          console.log('  memorix lock status [--file src/app.ts] [--agentId <id>]');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});

package/src/cli/commands/message.ts

@@ -1,27 +1,27 @@
-import { defineCommand } from 'citty';
+import { defineCommand } from 'citty';
 import { emitError, emitResult, getCliProjectContext, resolveCliActorId, shortId } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'message',
-    description: 'Send, broadcast, and read team messages from the CLI',
-  },
-  args: {
-    from: { type: 'string', description: 'Sender agent ID' },
-    to: { type: 'string', description: 'Recipient agent ID' },
-    type: { type: 'string', description: 'Message type (request, response, info, handoff, etc.)' },
-    content: { type: 'string', description: 'Message content' },
-    agentId: { type: 'string', description: 'Agent ID for inbox reads' },
-    markRead: { type: 'boolean', description: 'Mark inbox messages as read after listing them' },
-    toRole: { type: 'string', description: 'Optional role target for the message' },
-    handoffStatus: { type: 'string', description: 'Optional handoff status when type=handoff' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
+
+export default defineCommand({
+  meta: {
+    name: 'message',
+    description: 'Send, broadcast, and read team messages from the CLI',
+  },
+  args: {
+    from: { type: 'string', description: 'Sender agent ID' },
+    to: { type: 'string', description: 'Recipient agent ID' },
+    type: { type: 'string', description: 'Message type (request, response, info, handoff, etc.)' },
+    content: { type: 'string', description: 'Message content' },
+    agentId: { type: 'string', description: 'Agent ID for inbox reads' },
+    markRead: { type: 'boolean', description: 'Mark inbox messages as read after listing them' },
+    toRole: { type: 'string', description: 'Optional role target for the message' },
+    handoffStatus: { type: 'string', description: 'Optional handoff status when type=handoff' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    const asJson = !!args.json;
+
+    try {
       const { project, teamStore, identity } = await getCliProjectContext();
       const senderAgentId = resolveCliActorId(args.from, identity, 'from');
       const inboxAgentId = resolveCliActorId(
@@ -29,65 +29,65 @@ export default defineCommand({
         identity,
         'agentId',
       );
-
-      switch (action) {
-        case 'send': {
+
+      switch (action) {
+        case 'send': {
           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) {
-            emitError('Either --to or --toRole is required for "memorix message send"', asJson);
-            return;
-          }
-          const message = teamStore.sendMessage({
-            projectId: project.id,
+            return;
+          }
+          if (!args.to && !args.toRole) {
+            emitError('Either --to or --toRole is required for "memorix message send"', asJson);
+            return;
+          }
+          const message = teamStore.sendMessage({
+            projectId: project.id,
             senderAgentId,
-            recipientAgentId: (args.to as string | undefined) ?? null,
-            type: args.type as string,
-            content: args.content as string,
-            toRole: (args.toRole as string | undefined) ?? null,
-            handoffStatus:
-              (args.handoffStatus as string | undefined) ??
-              ((args.type as string) === 'handoff' ? 'open' : null),
-          });
-          if ('error' in message) {
-            emitError(message.error, asJson);
-            return;
-          }
-          emitResult(
-            { project, message },
-            `Message sent: ${shortId(message.id)} to ${args.to ? shortId(args.to as string) : `role ${args.toRole}`}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'broadcast': {
+            recipientAgentId: (args.to as string | undefined) ?? null,
+            type: args.type as string,
+            content: args.content as string,
+            toRole: (args.toRole as string | undefined) ?? null,
+            handoffStatus:
+              (args.handoffStatus as string | undefined) ??
+              ((args.type as string) === 'handoff' ? 'open' : null),
+          });
+          if ('error' in message) {
+            emitError(message.error, asJson);
+            return;
+          }
+          emitResult(
+            { project, message },
+            `Message sent: ${shortId(message.id)} to ${args.to ? shortId(args.to as string) : `role ${args.toRole}`}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'broadcast': {
           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,
+            return;
+          }
+          const message = teamStore.sendMessage({
+            projectId: project.id,
             senderAgentId,
-            recipientAgentId: null,
-            type: args.type as string,
-            content: args.content as string,
-          });
-          if ('error' in message) {
-            emitError(message.error, asJson);
-            return;
-          }
-          emitResult(
-            { project, message },
-            `Broadcast sent: ${shortId(message.id)}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'inbox': {
+            recipientAgentId: null,
+            type: args.type as string,
+            content: args.content as string,
+          });
+          if ('error' in message) {
+            emitError(message.error, asJson);
+            return;
+          }
+          emitResult(
+            { project, message },
+            `Broadcast sent: ${shortId(message.id)}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'inbox': {
           if (!inboxAgentId) {
             emitError('an active CLI identity or agentId is required for "memorix message inbox"', asJson);
             return;
@@ -96,31 +96,31 @@ export default defineCommand({
           const unreadCount = teamStore.getUnreadCount(project.id, inboxAgentId);
           if (args.markRead) {
             teamStore.markAllRead(project.id, inboxAgentId);
-          }
-          emitResult(
-            { project, unreadCount, messages },
-            messages.length === 0
-              ? 'Inbox empty.'
-              : [`Inbox: ${unreadCount} unread / ${messages.length} total`, '', ...messages.map((message) => {
-                  const sender = teamStore.getAgent(message.sender_agent_id);
-                  return `- ${message.read_at ? ' ' : '*'} [${message.type}] from ${sender?.name ?? shortId(message.sender_agent_id)}: ${message.content}`;
-                })].join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Message Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix message send --from <agentId> --to <agentId> --type info --content "..."');
-          console.log('  memorix message send --from <agentId> --toRole reviewer --type handoff --content "..."');
-          console.log('  memorix message broadcast --from <agentId> --type announcement --content "..."');
-          console.log('  memorix message inbox --agentId <id> [--markRead]');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
+          }
+          emitResult(
+            { project, unreadCount, messages },
+            messages.length === 0
+              ? 'Inbox empty.'
+              : [`Inbox: ${unreadCount} unread / ${messages.length} total`, '', ...messages.map((message) => {
+                  const sender = teamStore.getAgent(message.sender_agent_id);
+                  return `- ${message.read_at ? ' ' : '*'} [${message.type}] from ${sender?.name ?? shortId(message.sender_agent_id)}: ${message.content}`;
+                })].join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Message Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix message send --from <agentId> --to <agentId> --type info --content "..."');
+          console.log('  memorix message send --from <agentId> --toRole reviewer --type handoff --content "..."');
+          console.log('  memorix message broadcast --from <agentId> --type announcement --content "..."');
+          console.log('  memorix message inbox --agentId <id> [--markRead]');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});

package/src/cli/commands/operator-shared.ts

@@ -1,4 +1,5 @@
 import { detectProjectWithDiagnostics } from '../../project/detector.js';
+import { homeProjectRootError, isHomeDirectory, writeLastProjectRoot } from '../../project/launch-root.js';
 import { getProjectDataDir } from '../../store/persistence.js';
 import { initObservations, prepareSearchIndex } from '../../memory/observations.js';
 import { initSessionStore } from '../../store/session-store.js';
@@ -42,19 +43,22 @@ async function resolveCliProjectContext(options?: CliContextOptions): Promise<{
   invocation: ReturnType<typeof getCliInvocation>;
 }> {
   const invocation = getCliInvocation();
-  const detection = detectProjectWithDiagnostics(
-    options?.projectRoot
-      ?? invocation.projectRoot
-      ?? process.env.MEMORIX_PROJECT_ROOT
-      ?? process.cwd(),
-  );
-  if (!detection.project) {
-    const detail = detection.failure?.detail ?? 'No git repository found in the current directory.';
+  const requestedRoot = options?.projectRoot
+    ?? invocation.projectRoot
+    ?? process.env.MEMORIX_PROJECT_ROOT
+    ?? process.cwd();
+  if (isHomeDirectory(requestedRoot)) {
+    throw new Error(homeProjectRootError(requestedRoot));
+  }
+  const detection = detectProjectWithDiagnostics(requestedRoot);
+  if (!detection.project || isHomeDirectory(detection.project.rootPath)) {
+    const detail = detection.failure?.detail ?? homeProjectRootError(requestedRoot);
     throw new Error(detail);
   }
 
   const project = detection.project;
   const dataDir = await getProjectDataDir(project.id);
+  writeLastProjectRoot(project.rootPath);
   return { project, dataDir, invocation };
 }
 
@@ -65,10 +69,13 @@ async function resolveCliProjectContext(options?: CliContextOptions): Promise<{
  */
 export async function getCliReadContext(options?: CliContextOptions): Promise<CliReadContext> {
   const { project, dataDir, invocation } = await resolveCliProjectContext(options);
-  await initObservations(dataDir);
+  await initObservations(dataDir, {
+    embeddingWriteMode: 'deferred',
+    projectRoot: project.rootPath,
+  });
 
   if (options?.searchIndex) {
-    await prepareSearchIndex();
+    await prepareSearchIndex({ skipCachedVectors: true });
   }
 
   const storedIdentity = await loadCliIdentity(dataDir, project.id);
@@ -118,7 +125,7 @@ export async function getCliProjectContext(options?: CliContextOptions): Promise
   const teamStore = await initTeamStore(dataDir);
 
   if (options?.searchIndex) {
-    await prepareSearchIndex();
+    await prepareSearchIndex({ skipCachedVectors: true });
   }
 
   const identity = await resolveCliIdentity({

package/src/cli/commands/poll.ts

@@ -1,32 +1,32 @@
-import { defineCommand } from 'citty';
-import { computePoll, computeWatermark } from '../../team/poll.js';
-import { getObservationStore } from '../../store/obs-store.js';
+import { defineCommand } from 'citty';
+import { computePoll, computeWatermark } from '../../team/poll.js';
+import { getObservationStore } from '../../store/obs-store.js';
 import { getAllObservations } from '../../memory/observations.js';
 import { withFreshIndex } from '../../memory/freshness.js';
 import { filterReadableObservations } from '../../memory/visibility.js';
 import { emitError, emitResult, getCliProjectContext, resolveCliActorId, shortId } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'poll',
-    description: 'Get a full project coordination snapshot for an agent',
-  },
-  args: {
-    agentId: { type: 'string', description: 'Agent ID for personalized situational awareness' },
-    markInboxRead: { type: 'boolean', description: 'Mark all inbox messages as read after returning them' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const asJson = !!args.json;
-
-    try {
+
+export default defineCommand({
+  meta: {
+    name: 'poll',
+    description: 'Get a full project coordination snapshot for an agent',
+  },
+  args: {
+    agentId: { type: 'string', description: 'Agent ID for personalized situational awareness' },
+    markInboxRead: { type: 'boolean', description: 'Mark all inbox messages as read after returning them' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const asJson = !!args.json;
+
+    try {
       const { project, teamStore, identity, reader: activeReader } = await getCliProjectContext();
       const agentId = resolveCliActorId(args.agentId, identity);
       let reader = activeReader;
-
-      let watermark = computeWatermark(0, 0, 0);
-      if (agentId) {
-        const agent = teamStore.getAgent(agentId);
+
+      let watermark = computeWatermark(0, 0, 0);
+      if (agentId) {
+        const agent = teamStore.getAgent(agentId);
         if (!agent || agent.project_id !== project.id) {
           emitError(`Unknown agent "${agentId}"`, asJson);
           return;
@@ -36,45 +36,45 @@ export default defineCommand({
           agentId,
           isTeamMember: agent.status === 'active',
         };
-
-        const lastSeen = agent.last_seen_obs_generation;
-        const currentGen = getObservationStore().getGeneration();
-        const projectObs = await withFreshIndex(() =>
+
+        const lastSeen = agent.last_seen_obs_generation;
+        const currentGen = getObservationStore().getGeneration();
+        const projectObs = await withFreshIndex(() =>
           filterReadableObservations(
             getAllObservations().filter(
               (obs) => obs.projectId === project.id && (obs.writeGeneration ?? 0) > lastSeen,
             ),
             reader,
           ),
-        );
-        watermark = computeWatermark(lastSeen, currentGen, projectObs.length);
-        teamStore.updateWatermark(agentId, currentGen);
-        teamStore.heartbeat(agentId);
-      }
-
-      const poll = computePoll(teamStore, project.id, agentId ?? null, watermark);
-      if (args.markInboxRead && agentId) {
-        teamStore.markAllRead(project.id, agentId);
-      }
-
-      const text = [
-        poll.agent ? `You: ${shortId(poll.agent.agentId)} (${poll.agent.status})` : 'Project-level overview',
-        poll.watermark.newObservationCount > 0
-          ? `${poll.watermark.newObservationCount} new observation(s)`
-          : 'No unseen observations',
-        poll.inbox.unreadCount > 0 ? `${poll.inbox.unreadCount} unread message(s)` : 'Inbox clear',
-        poll.tasks.myInProgress.length > 0
-          ? `${poll.tasks.myInProgress.length} in-progress task(s)`
-          : 'No in-progress tasks',
-        poll.tasks.availableToClaim.length > 0
-          ? `${poll.tasks.availableToClaim.length} task(s) available to claim`
-          : 'No claimable tasks',
-        `Team: ${poll.team.activeAgents.length} active / ${poll.team.totalAgents} total`,
-      ].join('\n');
-
-      emitResult({ project, poll }, text, asJson);
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
+        );
+        watermark = computeWatermark(lastSeen, currentGen, projectObs.length);
+        teamStore.updateWatermark(agentId, currentGen);
+        teamStore.heartbeat(agentId);
+      }
+
+      const poll = computePoll(teamStore, project.id, agentId ?? null, watermark);
+      if (args.markInboxRead && agentId) {
+        teamStore.markAllRead(project.id, agentId);
+      }
+
+      const text = [
+        poll.agent ? `You: ${shortId(poll.agent.agentId)} (${poll.agent.status})` : 'Project-level overview',
+        poll.watermark.newObservationCount > 0
+          ? `${poll.watermark.newObservationCount} new observation(s)`
+          : 'No unseen observations',
+        poll.inbox.unreadCount > 0 ? `${poll.inbox.unreadCount} unread message(s)` : 'Inbox clear',
+        poll.tasks.myInProgress.length > 0
+          ? `${poll.tasks.myInProgress.length} in-progress task(s)`
+          : 'No in-progress tasks',
+        poll.tasks.availableToClaim.length > 0
+          ? `${poll.tasks.availableToClaim.length} task(s) available to claim`
+          : 'No claimable tasks',
+        `Team: ${poll.team.activeAgents.length} active / ${poll.team.totalAgents} total`,
+      ].join('\n');
+
+      emitResult({ project, poll }, text, asJson);
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});