memorix 1.9.4 → 1.9.6

package/plugins/omp/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-omp-package",
-  "version": "1.9.4",
+  "version": "1.9.6",
   "description": "Memorix shared workspace memory package for Oh-my-Pi.",
   "license": "Apache-2.0",
   "keywords": [

package/plugins/openclaw/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.9.4",
+  "version": "1.9.6",
   "description": "Shared workspace memory for OpenClaw and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/pi/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-pi-package",
-  "version": "1.9.4",
+  "version": "1.9.6",
   "description": "Memorix shared workspace memory package for Pi coding agent.",
   "license": "Apache-2.0",
   "keywords": [

package/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/AVIDS2/memorix",
     "source": "github"
   },
-  "version": "1.9.4",
+  "version": "1.9.6",
   "websiteUrl": "https://mem.rglens.com",
   "icons": [
     {
@@ -22,7 +22,7 @@
     {
       "registryType": "npm",
       "identifier": "memorix",
-      "version": "1.9.4",
+      "version": "1.9.6",
       "runtimeHint": "npx",
       "packageArguments": [
         {

package/src/cli/capability-map.ts

@@ -21,6 +21,7 @@ export const CLI_NATIVE_PARITY: Record<string, string> = Object.freeze({
   memorix_media: 'memorix media import|attach|list|show|generate|status',
   memorix_evidence: 'memorix evidence list|get|sync|stale|events',
   memorix_feedback: 'memorix feedback record|show|audit',
+  memorix_continuity: 'memorix continuity start|record|show|list|close',
   memorix_dashboard: 'memorix dashboard',
   memorix_handoff: 'memorix handoff send',
   memorix_poll: 'memorix poll',

package/src/cli/command-guide.ts

@@ -48,10 +48,22 @@ const GUIDES: Record<string, CliCommandGuide> = {
   context: {
     summary: 'Build the bounded task Workset used to resume or begin real work.',
     usage: [
-      'memorix context "continue the release fix" [--refresh auto|always|never]',
+      'memorix context "continue the release fix" [--task-id <continuity-id>] [--refresh auto|always|never]',
       'memorix resume "continue the release fix" [--refresh auto|always|never]',
     ],
   },
+  continuity: {
+    summary: 'Track task requirements, decisions, verification, risks, and outcomes.',
+    usage: [
+      'memorix continuity start --task "Harden the release path" [--requirements "a,b"]',
+      'memorix continuity record --task-id <id> --kind decision --content "..."',
+      'memorix continuity record --task-id <id> --kind verification --verification-status passed --content "..."',
+      'memorix continuity show --task-id <id>',
+      'memorix continuity close --task-id <id> --status completed --content "..."',
+      'memorix continuity list',
+    ],
+    notes: ['Pass the returned task id to memorix context --task-id so the bounded brief includes the ledger.'],
+  },
   explain: {
     summary: 'Show why a task context contains its current facts and memory evidence.',
     usage: ['memorix explain [--refresh auto|always|never]'],
@@ -213,11 +225,11 @@ const GUIDES: Record<string, CliCommandGuide> = {
       'memorix sync rules --action status',
       'memorix sync workspace --action scan',
       'memorix sync store status --json',
-      'memorix sync store push|pull [--dry] [--json]',
+      'memorix sync store push|pull [--dry] [--json] [--scope project|user]',
       'memorix sync store compact --dry --through device=sequence',
       'memorix sync store device rotate',
     ],
-    notes: ['Store sync is opt-in, project-scoped, and never copies the live SQLite database.'],
+    notes: ['Store sync is opt-in and never copies the live SQLite database. Default scope is the current Git project; `--scope user` relays every local project.'],
   },
   ingest: {
     summary: 'Ingest Git and image evidence into project memory.',

package/src/cli/commands/agent-integrations.ts

@@ -168,6 +168,8 @@ function worstStatus(statuses: AgentIntegrationStatus[]): AgentIntegrationStatus
 }
 
 function isMcpConfigAgent(agent: AgentName): agent is McpConfigAgent {
+  // Grok has a setup-only HTTP adapter. Doctor/repair skip it so a default
+  // host-owned Grok MCP is not reported as missing.
   return agent !== 'pi' && agent !== 'grok';
 }
 
@@ -773,7 +775,62 @@ async function inspectCodexPluginMcp(): Promise<AgentMcpCheck | null> {
   }
 }
 
+async function inspectOptionalGrokMcp(scope: AgentIntegrationScope): Promise<AgentIntegrationEntry['mcp']> {
+  if (scope === 'project' || scope === 'local') {
+    return { status: 'skipped', issues: ['mcp-host-owned'], checks: [] };
+  }
+
+  const adapter = getMcpAdapter('grok');
+  const configPath = adapter.getConfigPath();
+  if (!existsSync(configPath)) {
+    return {
+      status: 'skipped',
+      issues: ['mcp-host-owned'],
+      checks: [{
+        scope: 'global',
+        path: configPath,
+        exists: false,
+        status: 'skipped',
+        issues: ['mcp-host-owned'],
+      }],
+    };
+  }
+
+  const content = await readFile(configPath, 'utf-8');
+  const server = adapter.parse(content).find((entry) => entry.name === 'memorix');
+  if (!server) {
+    return {
+      status: 'skipped',
+      issues: ['mcp-host-owned'],
+      checks: [{
+        scope: 'global',
+        path: configPath,
+        exists: true,
+        status: 'skipped',
+        issues: ['mcp-host-owned'],
+      }],
+    };
+  }
+
+  const issues: string[] = [];
+  if (!server.url && looksLikeStaleMemorixCommand(server)) issues.push('stale-command-path');
+  if (!server.url && !isRecommendedStdioServer(server)) issues.push('nonstandard-mcp-command');
+  return {
+    status: issues.length > 0 ? 'repairable' : 'ok',
+    issues,
+    checks: [{
+      scope: 'global',
+      path: configPath,
+      exists: true,
+      status: issues.length > 0 ? 'repairable' : 'ok',
+      issues,
+      server: sanitizeServer(server),
+    }],
+  };
+}
+
 async function inspectMcp(agent: AgentName, projectRoot: string, scope: AgentIntegrationScope): Promise<AgentIntegrationEntry['mcp']> {
+  if (agent === 'grok') return inspectOptionalGrokMcp(scope);
   if (!isMcpConfigAgent(agent)) {
     return { status: 'skipped', issues: ['mcp-managed-by-package'], checks: [] };
   }

package/src/cli/commands/background.ts

@@ -570,8 +570,17 @@ async function doStartUnlocked(port: number): Promise<void> {
   if (healthy) {
     process.stderr.write('[OK] Control plane is running and healthy.\n');
   } else {
-    process.stderr.write('[WARN] Health check timed out — service may still be initializing.\n');
-    process.stderr.write('  Check later:  memorix background status\n');
+    process.stderr.write('[ERROR] Health check timed out; refusing to leave an unverified background state.\n');
+    if (isProcessRunning(pid)) {
+      killProcess(pid);
+      for (let i = 0; i < 10 && isProcessRunning(pid); i++) {
+        await new Promise(r => setTimeout(r, 250));
+      }
+    }
+    clearState();
+    try { fs.unlinkSync(getMemorixDir() + '/background.ready'); } catch { /* best effort */ }
+    process.exitCode = 1;
+    return;
   }
 
   const footer = [

package/src/cli/commands/context.ts

@@ -33,6 +33,7 @@ export default defineCommand({
   },
   args: {
     task: { type: 'string', description: 'Current task for context shaping' },
+    taskId: { type: 'string', description: 'Optional task continuity ledger id to include' },
     input: {
       type: 'positional',
       description: 'Current task for context shaping (ergonomic positional form)',
@@ -67,6 +68,7 @@ export default defineCommand({
         dataDir,
         observations: filterReadableObservations(getAllObservations(), reader),
         task,
+        taskId: (args.taskId as string | undefined)?.trim() || undefined,
         agent: coerceAgentTarget(args.agent as string | undefined),
         refresh: coerceRefreshMode(args.refresh as string | undefined),
         reader,

package/src/cli/commands/continuity.ts

@@ -0,0 +1,155 @@
+import { defineCommand } from 'citty';
+import {
+  TaskContinuityStore,
+  type TaskContinuityEventKind,
+  type TaskContinuityOutcomeStatus,
+  type TaskContinuityVerificationStatus,
+} from '../../knowledge/task-continuity.js';
+import {
+  emitError,
+  emitResult,
+  getCliProjectContext,
+  parseCsvList,
+} from './operator-shared.js';
+
+const recordKinds: Array<Exclude<TaskContinuityEventKind, 'task' | 'outcome'>> = [
+  'requirement',
+  'decision',
+  'verification',
+  'risk',
+];
+
+export default defineCommand({
+  meta: {
+    name: 'continuity',
+    description: 'Track task requirements, decisions, verification, risks, and outcomes',
+  },
+  args: {
+    taskId: { type: 'string', description: 'Continuity task id' },
+    task: { type: 'string', description: 'Task description for start' },
+    requirements: { type: 'string', description: 'Comma-separated requirements for start' },
+    kind: { type: 'string', description: 'requirement, decision, verification, or risk' },
+    content: { type: 'string', description: 'Entry or outcome text' },
+    verificationStatus: { type: 'string', description: 'pending, passed, failed, or skipped' },
+    verificationId: { type: 'string', description: 'Stable verification obligation id for status transitions' },
+    idempotencyKey: { type: 'string', description: 'Stable retry key for idempotent writes' },
+    status: { type: 'string', description: 'completed, blocked, or abandoned for close' },
+    source: { type: 'string', description: 'Source or evidence reference' },
+    evidence: { type: 'string', description: 'Comma-separated evidence references' },
+    actor: { type: 'string', description: 'Actor id or label' },
+    limit: { type: 'string', description: 'Maximum ledgers for list' },
+    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, dataDir, identity } = await getCliProjectContext({ searchIndex: false });
+      const store = new TaskContinuityStore();
+      await store.init(dataDir);
+      const actor = String(args.actor || identity?.agentId || '').trim() || undefined;
+      if (action === 'start') {
+        if (!args.task) {
+          emitError('task is required for "memorix continuity start"', asJson);
+          return;
+        }
+        const result = store.start({
+          projectId: project.id,
+          task: String(args.task),
+          ...(args.taskId ? { taskId: String(args.taskId) } : {}),
+          requirements: parseCsvList(args.requirements as string | undefined),
+          ...(actor ? { actor } : {}),
+          ...(args.idempotencyKey ? { idempotencyKey: String(args.idempotencyKey) } : {}),
+        });
+        emitResult({ project, ...result }, 'Continuity started: ' + result.taskId, asJson);
+        return;
+      }
+      if (action === 'list') {
+        const ledgers = store.list(project.id, Number(args.limit || 20));
+        emitResult(
+          { project, ledgers },
+          ledgers.length
+            ? ledgers.map(item => item.status + ': ' + item.taskId + ' ' + item.task).join('\n')
+            : 'No continuity ledgers found.',
+          asJson,
+        );
+        return;
+      }
+      const taskId = String(args.taskId || '').trim();
+      if (!taskId) {
+        emitError('taskId is required for this continuity action.', asJson);
+        return;
+      }
+      if (action === 'show') {
+        const ledger = store.get(project.id, taskId);
+        if (!ledger) {
+          emitError('Task continuity ledger not found.', asJson);
+          return;
+        }
+        emitResult({ project, ledger }, JSON.stringify(ledger, null, 2), asJson);
+        return;
+      }
+      if (action === 'record') {
+        const kind = String(args.kind || '').trim() as Exclude<TaskContinuityEventKind, 'task' | 'outcome'>;
+        const content = String(args.content || '').trim();
+        if (!recordKinds.includes(kind) || !content) {
+          emitError('record requires --kind (requirement, decision, verification, risk) and --content.', asJson);
+          return;
+        }
+        const verificationStatus = args.verificationStatus
+          ? String(args.verificationStatus).trim() as TaskContinuityVerificationStatus
+          : undefined;
+        if (verificationStatus && !['pending', 'passed', 'failed', 'skipped'].includes(verificationStatus)) {
+          emitError('verificationStatus must be pending, passed, failed, or skipped.', asJson);
+          return;
+        }
+        const result = store.record({
+          projectId: project.id,
+          taskId,
+          kind,
+          content,
+          ...(verificationStatus ? { verificationStatus } : {}),
+          ...(args.source ? { sourceRef: String(args.source) } : {}),
+          evidenceRefs: parseCsvList(args.evidence as string | undefined),
+          ...(actor ? { actor } : {}),
+          ...(args.verificationId ? { verificationId: String(args.verificationId) } : {}),
+          ...(args.idempotencyKey ? { idempotencyKey: String(args.idempotencyKey) } : {}),
+        });
+        emitResult({ project, ...result }, 'Continuity recorded: ' + kind, asJson);
+        return;
+      }
+      if (action === 'close') {
+        const status = String(args.status || '').trim() as TaskContinuityOutcomeStatus;
+        const content = String(args.content || '').trim();
+        if (!['completed', 'blocked', 'abandoned'].includes(status) || !content) {
+          emitError('close requires --status (completed, blocked, abandoned) and --content.', asJson);
+          return;
+        }
+        const result = store.close({
+          projectId: project.id,
+          taskId,
+          status,
+          content,
+          ...(args.source ? { sourceRef: String(args.source) } : {}),
+          evidenceRefs: parseCsvList(args.evidence as string | undefined),
+          ...(actor ? { actor } : {}),
+          ...(args.idempotencyKey ? { idempotencyKey: String(args.idempotencyKey) } : {}),
+        });
+        emitResult({ project, ...result }, 'Continuity closed: ' + status, asJson);
+        return;
+      }
+      console.log('Memorix Task Continuity');
+      console.log('');
+      console.log('Usage:');
+      console.log('  memorix continuity start --task "..." [--requirements "a,b"]');
+      console.log('  memorix continuity record --taskId <id> --kind decision --content "..."');
+      console.log('  memorix continuity record --taskId <id> --kind verification --verificationStatus passed --content "..."');
+      console.log('    Use --verificationId <id> to transition an existing verification obligation.');
+      console.log('  memorix continuity show --taskId <id>');
+      console.log('  memorix continuity list [--limit 20]');
+      console.log('  memorix continuity close --taskId <id> --status completed --content "..."');
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});

package/src/cli/commands/init.ts

@@ -21,7 +21,7 @@ import {
   type InitScope,
 } from './init-shared.js';
 
-type InitLlmProvider = 'none' | 'openai' | 'anthropic' | 'openrouter' | 'custom';
+type InitLlmProvider = 'none' | 'openai' | 'anthropic' | 'openrouter' | 'atlascloud' | 'custom';
 type InitEmbeddingProvider = 'off' | 'api' | 'fastembed';
 type InitInjectMode = 'minimal' | 'full' | 'silent';
 
@@ -103,6 +103,7 @@ export default defineCommand({
         { value: 'openai', label: 'OpenAI', hint: 'gpt-4o-mini' },
         { value: 'anthropic', label: 'Anthropic', hint: 'claude-3-haiku' },
         { value: 'openrouter', label: 'OpenRouter', hint: 'multi-provider' },
+        { value: 'atlascloud', label: 'Atlas Cloud', hint: 'DeepSeek V3.2' },
         { value: 'custom', label: 'Custom', hint: 'OpenAI-compatible endpoint' },
       ],
     });
@@ -162,7 +163,7 @@ export default defineCommand({
 
     if (llmProvider !== 'none') {
       envLines.push('# LLM API key');
-      if (llmProvider === 'openai' || llmProvider === 'custom') {
+      if (llmProvider === 'openai' || llmProvider === 'custom' || llmProvider === 'atlascloud') {
         envLines.push('MEMORIX_LLM_API_KEY=sk-your-key-here');
       } else if (llmProvider === 'anthropic') {
         envLines.push('MEMORIX_LLM_API_KEY=sk-ant-your-key-here');
@@ -292,6 +293,8 @@ export function buildInitTomlConfig(options: {
       lines.push('model = "claude-3-haiku-20240307"');
     } else if (options.llmProvider === 'openrouter') {
       lines.push('# model = "openai/gpt-4o-mini"');
+    } else if (options.llmProvider === 'atlascloud') {
+      lines.push('model = "deepseek-ai/deepseek-v3.2"');
     }
     if (options.llmProvider === 'custom') {
       lines.push('# OpenAI-compatible endpoint, for example DashScope, DeepSeek, Ollama, or an internal gateway.');