memorix 1.2.7 → 1.2.9

package/src/runtime/vector-backfill-runner.ts

@@ -0,0 +1,144 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { loadDotenv } from '../config/dotenv-loader.js';
+import { initProjectRoot } from '../config/yaml-loader.js';
+import { prepareSearchIndex, initObservations } from '../memory/observations.js';
+import { sanitizeCredentials } from '../memory/secret-filter.js';
+import { initObservationStore } from '../store/obs-store.js';
+import { getDeferredCachedVectorHydration } from '../store/orama-store.js';
+import { closeAllDatabases } from '../store/sqlite-db.js';
+import { MaintenanceJobStore, MaintenanceJobWorker } from './maintenance-jobs.js';
+import { createProjectMaintenanceHandler } from './project-maintenance.js';
+
+export interface VectorBackfillRequest {
+  projectId: string;
+  projectRoot: string;
+  dataDir: string;
+}
+
+export interface VectorBackfillLauncherOptions {
+  runnerPath?: string;
+  exists?: (path: string) => boolean;
+  spawn?: typeof spawn;
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+/** Resolve the standalone worker next to either the library or CLI bundle. */
+export function resolveVectorBackfillRunnerPath(moduleUrl = import.meta.url): string {
+  const moduleDir = path.dirname(fileURLToPath(moduleUrl));
+  const distDir = path.basename(moduleDir) === 'cli'
+    ? path.dirname(moduleDir)
+    : path.basename(moduleDir) === 'runtime' && path.basename(path.dirname(moduleDir)) === 'src'
+      ? path.join(path.dirname(path.dirname(moduleDir)), 'dist')
+      : moduleDir;
+  return path.join(distDir, 'vector-backfill-runner.js');
+}
+
+/** Parse the internal request passed from a short-lived CLI process. */
+export function parseVectorBackfillRequest(raw: string): VectorBackfillRequest {
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error('Vector backfill runner received invalid JSON input');
+  }
+
+  if (
+    !value ||
+    typeof value !== 'object' ||
+    !isNonEmptyString((value as VectorBackfillRequest).projectId) ||
+    !isNonEmptyString((value as VectorBackfillRequest).projectRoot) ||
+    !isNonEmptyString((value as VectorBackfillRequest).dataDir) ||
+    !path.isAbsolute((value as VectorBackfillRequest).projectRoot) ||
+    !path.isAbsolute((value as VectorBackfillRequest).dataDir)
+  ) {
+    throw new Error('Vector backfill runner received an invalid request');
+  }
+
+  return {
+    projectId: (value as VectorBackfillRequest).projectId,
+    projectRoot: (value as VectorBackfillRequest).projectRoot,
+    dataDir: (value as VectorBackfillRequest).dataDir,
+  };
+}
+
+/**
+ * Start a detached one-shot worker. The caller has already persisted the
+ * observation and durable vector job, so failure to start is recoverable by a
+ * later MCP or control-plane session.
+ */
+export function launchDetachedVectorBackfill(
+  request: VectorBackfillRequest,
+  options: VectorBackfillLauncherOptions = {},
+): boolean {
+  const runnerPath = options.runnerPath ?? resolveVectorBackfillRunnerPath();
+  const exists = options.exists ?? existsSync;
+  if (!exists(runnerPath)) return false;
+
+  try {
+    const child = (options.spawn ?? spawn)(process.execPath, [runnerPath], {
+      cwd: request.projectRoot,
+      detached: true,
+      stdio: 'ignore',
+      // The request contains only local project metadata, never credentials.
+      // Environment transport avoids a live stdin pipe keeping the CLI alive.
+      env: { ...process.env, MEMORIX_VECTOR_BACKFILL_REQUEST: JSON.stringify(request) },
+      windowsHide: true,
+    }) as ChildProcess;
+    child.once?.('error', () => {});
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Run one durable vector-backfill job without sharing the CLI event loop. */
+export async function executeVectorBackfill(request: VectorBackfillRequest) {
+  initProjectRoot(request.projectRoot);
+  loadDotenv(request.projectRoot);
+  await initObservationStore(request.dataDir);
+  await initObservations(request.dataDir);
+  await prepareSearchIndex();
+  await getDeferredCachedVectorHydration()?.catch(() => {});
+
+  const worker = new MaintenanceJobWorker(
+    new MaintenanceJobStore(request.dataDir),
+    createProjectMaintenanceHandler(request.projectId, request.dataDir, request.projectRoot),
+    { projectId: request.projectId, kinds: ['vector-backfill'] },
+  );
+  return worker.runOnce();
+}
+
+async function readStdin(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let raw = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { raw += chunk; });
+    process.stdin.once('error', reject);
+    process.stdin.once('end', () => resolve(raw));
+  });
+}
+
+export async function main(): Promise<void> {
+  try {
+    const raw = process.env.MEMORIX_VECTOR_BACKFILL_REQUEST ?? await readStdin();
+    await executeVectorBackfill(parseVectorBackfillRequest(raw));
+  } catch (error) {
+    const detail = sanitizeCredentials(error instanceof Error ? error.message : String(error));
+    process.stderr.write(`[memorix] vector backfill worker failed: ${detail}\n`);
+    process.exitCode = 1;
+  } finally {
+    closeAllDatabases();
+  }
+}
+
+if (process.argv[1] && process.argv[1].endsWith('vector-backfill-runner.js')) {
+  void main();
+}

package/src/search/intent-detector.ts

@@ -12,7 +12,7 @@ import type { ObservationType } from '../types.js';
 
 // ─── Types ───
 
-export type QueryIntent = 'why' | 'when' | 'how' | 'what_changed' | 'problem' | 'general';
+export type QueryIntent = 'why' | 'when' | 'how' | 'what_changed' | 'problem' | 'state' | 'general';
 
 export interface IntentResult {
   /** Detected intent category */
@@ -39,6 +39,30 @@ interface IntentPattern {
 }
 
 const INTENT_PATTERNS: IntentPattern[] = [
+  {
+    // Resumption queries — "where were we", "what's left". Weighted just above the
+    // others because these are asked at handoff time, when returning the current
+    // state matters more than returning the best semantic match.
+    intent: 'state',
+    patterns: [
+      /\bprogress\b/i,
+      /\bstatus\b/i,
+      /\bremaining\b/i,
+      /\bnext steps?\b/i,
+      /\bwhere (?:did|are) we\b/i,
+      /\bpick(?:ing)? up\b/i,
+      /\bresume\b/i,
+      /\bto-?do\b/i,
+      /进度/,
+      /做到哪/,
+      /下一步/,
+      /待办/,
+      /剩下/,
+      /继续/,
+      /接着做/,
+    ],
+    weight: 1.1,
+  },
   {
     intent: 'why',
     patterns: [
@@ -139,6 +163,12 @@ const INTENT_PATTERNS: IntentPattern[] = [
 // ─── Type Boost Maps ───
 
 const INTENT_TYPE_BOOSTS: Record<QueryIntent, Partial<Record<ObservationType, number>>> = {
+  state: {
+    'session-request': 2.5,
+    'what-changed': 2.0,
+    'discovery': 1.5,
+    'problem-solution': 1.2,
+  },
   why: {
     'decision': 3.0,
     'why-it-exists': 3.0,
@@ -198,6 +228,14 @@ const INTENT_SOURCE_BOOSTS: Partial<Record<QueryIntent, Partial<Record<'agent' |
 };
 
 const INTENT_FIELD_BOOSTS: Partial<Record<QueryIntent, Record<string, number>>> = {
+  state: {
+    title: 3,           // State notes are titled by topic — the title carries the signal
+    entityName: 1.5,
+    narrative: 2,
+    facts: 2.5,         // Progress lines usually live in facts
+    concepts: 1,
+    filesModified: 0.5,
+  },
   why: {
     title: 2,
     entityName: 1.5,

package/src/server.ts

@@ -3637,7 +3637,7 @@ export async function createMemorixServer(
   /**
    * memorix_session_start — Start a new coding session
    *
-   * Creates a session record and returns context from previous sessions.
+   * Creates a session record and returns a compact continuation card.
    * This is the entry point for session-aware memory management.
    */
   server.registerTool(
@@ -3645,10 +3645,10 @@ export async function createMemorixServer(
     {
       title: 'Start Session',
       description:
-        'Start a new coding session. Returns context from previous sessions so you can resume work seamlessly. ' +
-        'Call this at the beginning of a session to track activity and get injected context. ' +
+        'Start a new coding session. Returns a compact continuation card with the latest handoff and a few memory references. ' +
+        'Call this at the beginning of a session to track activity; retrieve a referenced memory only when it is relevant. ' +
         'Any previous active session for this project will be auto-closed. ' +
-        'By default this is lightweight: it binds the project, opens a session, and injects context only. ' +
+        'By default this is lightweight: it binds the project, opens a session, and avoids dumping full history into the new context. ' +
         'Coordination identity is opt-in via `joinTeam: true` or a separate `team_manage` join call.\n\n' +
         'IMPORTANT for HTTP/control-plane mode: pass `projectRoot` with the absolute path to your ' +
         'workspace root (e.g., the directory open in your IDE). Memorix uses this to detect the git ' +
@@ -3851,7 +3851,7 @@ export async function createMemorixServer(
       } catch { /* mini-skills not available yet — skip */ }
 
       if (result.previousContext) {
-        lines.push('---', '[TASK] **Context from previous sessions:**', '', result.previousContext);
+        lines.push('---', '[TASK] **Continuation card:**', '', result.previousContext);
       } else {
         lines.push('No previous session context found. This appears to be a fresh project.');
       }