memorix 1.5.0 → 1.6.0

package/dist/types.d.ts

@@ -360,6 +360,8 @@ interface SearchOptions {
      * `thorough` explicitly permits optional LLM query rewrite and reranking.
      */
     quality?: RetrievalQuality;
+    /** Abort provider-backed retrieval when the owning request is cancelled. */
+    signal?: AbortSignal;
 }
 /** Topic key family heuristics for suggesting stable topic keys */
 declare const TOPIC_KEY_FAMILIES: Record<string, string[]>;

package/dist/vector-backfill-runner.js

@@ -2755,6 +2755,8 @@ function getPreferredBatchSize(config) {
 }
 function parseBatchLimit(error) {
   if (!(error instanceof Error)) return null;
+  const status = error instanceof EmbeddingAPIError ? error.status : Number(error.message.match(/Embedding API error \((\d{3})\)/i)?.[1] ?? 0);
+  if (status > 0 && status !== 400) return null;
   const explicit = error.message.match(/should not be larger than\s+(\d+)/i);
   if (explicit) return parseInt(explicit[1], 10);
   if (/batch size/i.test(error.message)) {
@@ -2767,37 +2769,99 @@ async function fetchWithRetry(url, apiKey, body, options = {}, attempt = 0, nati
   const controller = new AbortController();
   const timeoutMs = typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) ? Math.max(100, Math.min(Math.floor(options.timeoutMs), 6e4)) : 1e4;
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
   let response;
   try {
     response = await fetch(url, {
       method: "POST",
       headers: nativeGemini ? { "Content-Type": "application/json", "x-goog-api-key": apiKey } : { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` },
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal
     });
   } catch (err) {
     clearTimeout(timeout);
-    if (err instanceof Error && err.name === "AbortError") {
+    if (err instanceof Error && (err.name === "AbortError" || controller.signal.aborted || options.signal?.aborted)) {
       throw new Error(`Embedding API timeout after ${timeoutMs}ms: ${url}`);
     }
     throw err;
   }
-  clearTimeout(timeout);
-  if (response.ok) {
-    return response.json();
+  try {
+    if (response.ok) {
+      return await raceWithAbort(
+        response.json(),
+        signal
+      );
+    }
+    if (options.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
+      const delay2 = BASE_DELAY_MS * Math.pow(2, attempt);
+      const retryAfter = response.headers.get("retry-after");
+      const parsedRetryAfter = retryAfter ? parseInt(retryAfter, 10) * 1e3 : NaN;
+      const waitMs = Number.isFinite(parsedRetryAfter) ? parsedRetryAfter : delay2;
+      console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES2} in ${waitMs}ms`);
+      await waitForRetry(waitMs, options.signal);
+      return fetchWithRetry(url, apiKey, body, options, attempt + 1, nativeGemini);
+    }
+    const errorText2 = await raceWithAbort(
+      response.text().catch(() => "unknown error"),
+      signal
+    );
+    throw new EmbeddingAPIError(response.status, errorText2);
+  } catch (err) {
+    if (err instanceof Error && (err.name === "AbortError" || controller.signal.aborted || options.signal?.aborted)) {
+      throw new Error(`Embedding API timeout after ${timeoutMs}ms: ${url}`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timeout);
   }
-  if (options.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
-    const delay2 = BASE_DELAY_MS * Math.pow(2, attempt);
-    const retryAfter = response.headers.get("retry-after");
-    const waitMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : delay2;
-    console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES2} in ${waitMs}ms`);
+}
+function abortError() {
+  const error = new Error("Embedding API request aborted");
+  error.name = "AbortError";
+  return error;
+}
+function raceWithAbort(promise, signal) {
+  if (signal.aborted) return Promise.reject(abortError());
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(abortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+async function waitForRetry(waitMs, signal) {
+  if (!signal) {
     await new Promise((resolve) => setTimeout(resolve, waitMs));
-    return fetchWithRetry(url, apiKey, body, options, attempt + 1, nativeGemini);
+    return;
   }
-  const errorText2 = await response.text().catch(() => "unknown error");
-  throw new Error(`Embedding API error (${response.status}): ${errorText2}`);
+  const abortSignal = signal;
+  if (abortSignal.aborted) throw new Error("Embedding API retry aborted");
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(done, waitMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      abortSignal.removeEventListener("abort", onAbort);
+      reject(new Error("Embedding API retry aborted"));
+    };
+    function done() {
+      abortSignal.removeEventListener("abort", onAbort);
+      resolve();
+    }
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  });
 }
-var cache3, MAX_CACHE_SIZE3, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES2, BASE_DELAY_MS, APIEmbeddingProvider;
+var cache3, MAX_CACHE_SIZE3, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES2, BASE_DELAY_MS, EmbeddingAPIError, APIEmbeddingProvider;
 var init_api_provider = __esm({
   "src/embedding/api-provider.ts"() {
     "use strict";
@@ -2816,6 +2880,14 @@ var init_api_provider = __esm({
     DASHSCOPE_MAX_BATCH_SIZE = 10;
     MAX_RETRIES2 = 3;
     BASE_DELAY_MS = 500;
+    EmbeddingAPIError = class extends Error {
+      status;
+      constructor(status, detail) {
+        super(`Embedding API error (${status}): ${detail}`);
+        this.name = "EmbeddingAPIError";
+        this.status = status;
+      }
+    };
     APIEmbeddingProvider = class _APIEmbeddingProvider {
       name;
       dimensions;
@@ -3027,15 +3099,14 @@ var init_api_provider = __esm({
             }
           } catch (error) {
             const providerLimit = parseBatchLimit(error);
-            const fallbackSize = providerLimit ?? Math.ceil(chunkTexts.length / 2);
-            if (chunkTexts.length > 1 && fallbackSize < chunkTexts.length) {
+            if (providerLimit !== null && chunkTexts.length > 1 && providerLimit < chunkTexts.length) {
               console.error(
-                `[memorix] Embedding batch too large for provider, retrying in chunks of ${fallbackSize}`
+                `[memorix] Embedding batch too large for provider, retrying in chunks of ${providerLimit}`
               );
-              for (let start = 0; start < chunkTexts.length; start += fallbackSize) {
+              for (let start = 0; start < chunkTexts.length; start += providerLimit) {
                 await processChunk(
-                  chunkTexts.slice(start, start + fallbackSize),
-                  chunkIndices.slice(start, start + fallbackSize)
+                  chunkTexts.slice(start, start + providerLimit),
+                  chunkIndices.slice(start, start + providerLimit)
                 );
               }
               return;
@@ -3899,22 +3970,23 @@ function getLLMConfig() {
 function setLLMConfig(config) {
   currentConfig = config;
 }
-async function callLLM(systemPrompt, userMessage) {
+async function callLLM(systemPrompt, userMessage, signal) {
   if (!currentConfig) {
     throw new Error("LLM not configured. Set MEMORIX_LLM_API_KEY or OPENAI_API_KEY.");
   }
   if (currentConfig.provider === "anthropic") {
-    return callAnthropic(systemPrompt, userMessage);
+    return callAnthropic(systemPrompt, userMessage, signal);
   }
-  return callOpenAICompatible(systemPrompt, userMessage);
+  return callOpenAICompatible(systemPrompt, userMessage, signal);
 }
-async function callOpenAICompatible(systemPrompt, userMessage) {
+async function callOpenAICompatible(systemPrompt, userMessage, signal) {
   const config = currentConfig;
   let base = config.baseUrl.replace(/\/+$/, "");
   if (!base.endsWith("/v1")) base += "/v1";
   const url = `${base}/chat/completions`;
+  const fetchSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(LLM_CALL_TIMEOUT_MS)]) : AbortSignal.timeout(LLM_CALL_TIMEOUT_MS);
   const response = await fetch(url, {
-    signal: AbortSignal.timeout(LLM_CALL_TIMEOUT_MS),
+    signal: fetchSignal,
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -3931,10 +4003,10 @@ async function callOpenAICompatible(systemPrompt, userMessage) {
     })
   });
   if (!response.ok) {
-    const error = await readResponseText(response, void 0, 64 * 1024).catch(() => "unknown error");
+    const error = await readResponseText(response, signal, 64 * 1024).catch(() => "unknown error");
     throw new Error(`LLM API error (${response.status}): ${error}`);
   }
-  const data = await readResponseJson(response);
+  const data = await readResponseJson(response, signal);
   return {
     content: data.choices[0]?.message?.content ?? "",
     usage: data.usage ? {
@@ -3943,11 +4015,12 @@ async function callOpenAICompatible(systemPrompt, userMessage) {
     } : void 0
   };
 }
-async function callAnthropic(systemPrompt, userMessage) {
+async function callAnthropic(systemPrompt, userMessage, signal) {
   const config = currentConfig;
   const url = `${config.baseUrl}/messages`;
+  const fetchSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(LLM_CALL_TIMEOUT_MS)]) : AbortSignal.timeout(LLM_CALL_TIMEOUT_MS);
   const response = await fetch(url, {
-    signal: AbortSignal.timeout(LLM_CALL_TIMEOUT_MS),
+    signal: fetchSignal,
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -3965,10 +4038,10 @@ async function callAnthropic(systemPrompt, userMessage) {
     })
   });
   if (!response.ok) {
-    const error = await readResponseText(response, void 0, 64 * 1024).catch(() => "unknown error");
+    const error = await readResponseText(response, signal, 64 * 1024).catch(() => "unknown error");
     throw new Error(`Anthropic API error (${response.status}): ${error}`);
   }
-  const data = await readResponseJson(response);
+  const data = await readResponseJson(response, signal);
   return {
     content: data.content[0]?.text ?? "",
     usage: data.usage ? {
@@ -4473,6 +4546,57 @@ function withTimeout(promise, ms, label) {
     );
   });
 }
+function withTimeoutSignal(operation, ms, label, parentSignal) {
+  const controller = new AbortController();
+  const signal = parentSignal ? AbortSignal.any([parentSignal, controller.signal]) : controller.signal;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timedOut = false;
+    let timer;
+    const cleanup = () => {
+      if (timer !== void 0) clearTimeout(timer);
+      parentSignal?.removeEventListener("abort", onParentAbort);
+    };
+    const onParentAbort = () => {
+      if (settled || timedOut) return;
+      settled = true;
+      cleanup();
+      reject(parentSignal?.reason ?? new Error(`${label} aborted`));
+    };
+    parentSignal?.addEventListener("abort", onParentAbort, { once: true });
+    timer = setTimeout(() => {
+      if (settled) return;
+      timedOut = true;
+      controller.abort(new Error(`${label} timed out after ${ms}ms`));
+      settled = true;
+      cleanup();
+      reject(new Error(`${label} timed out after ${ms}ms`));
+    }, ms);
+    let pending;
+    try {
+      pending = operation(signal);
+    } catch (error) {
+      settled = true;
+      cleanup();
+      reject(error);
+      return;
+    }
+    pending.then(
+      (value) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(value);
+      },
+      (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(timedOut ? new Error(`${label} timed out after ${ms}ms`) : error);
+      }
+    );
+  });
+}
 var init_timeout = __esm({
   "src/timeout.ts"() {
     "use strict";
@@ -5337,16 +5461,18 @@ async function searchObservations(options) {
           );
         } else {
           const EMBEDDING_TIMEOUT_MS = 15e3;
-          queryVector = await withTimeout(
-            provider2.embedInput ? provider2.embedInput(
+          queryVector = await withTimeoutSignal(
+            (signal) => provider2.embedInput ? provider2.embedInput(
               { modality: "text", text: expandedEmbeddingQuery },
-              { intent: "query", timeoutMs: EMBEDDING_TIMEOUT_MS, retry: false }
+              { intent: "query", timeoutMs: EMBEDDING_TIMEOUT_MS, retry: false, signal }
             ) : provider2.embed(expandedEmbeddingQuery, {
               timeoutMs: EMBEDDING_TIMEOUT_MS,
-              retry: false
+              retry: false,
+              signal
             }),
             EMBEDDING_TIMEOUT_MS,
-            "Embedding"
+            "Embedding",
+            options.signal
           );
           mark("embedding");
           const cjkRatio = (originalQuery.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g) || []).length / originalQuery.length;
@@ -145244,7 +145370,13 @@ async function maintainLongTermMemories(input) {
   }
   for (const group of groups.values()) {
     if (group.length < 2) continue;
-    group.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+    group.sort((a, b) => {
+      const byCreatedAt = Date.parse(b.createdAt) - Date.parse(a.createdAt);
+      if (byCreatedAt !== 0) return byCreatedAt;
+      const byUpdatedAt = Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+      if (byUpdatedAt !== 0) return byUpdatedAt;
+      return b.id.localeCompare(a.id);
+    });
     const newest = group[0];
     for (const older of group.slice(1)) {
       try {
@@ -147648,6 +147780,7 @@ var init_task_lens = __esm({
 var workflows_exports = {};
 __export(workflows_exports, {
   WORKFLOW_ADAPTER_TARGETS: () => WORKFLOW_ADAPTER_TARGETS,
+  WORKFLOW_AGENT_TARGETS: () => WORKFLOW_AGENT_TARGETS,
   applyWorkflowAdapter: () => applyWorkflowAdapter,
   importWindsurfWorkflows: () => importWindsurfWorkflows,
   parseWorkflowMarkdown: () => parseWorkflowMarkdown,
@@ -147713,7 +147846,7 @@ function optionalStatus(data) {
   return value;
 }
 function normalizeAgents(values) {
-  const unknown3 = values.filter((value) => !KNOWN_AGENTS.includes(value));
+  const unknown3 = values.filter((value) => !WORKFLOW_AGENT_TARGETS.includes(value));
   if (unknown3.length > 0) {
     throw new Error("workflow frontmatter has unsupported agent: " + unknown3[0]);
   }
@@ -147989,7 +148122,7 @@ function taskScore(workflow, task) {
   return { score, reasons: [...new Set(reasons)] };
 }
 function selectWorkflows(input) {
-  const selected = input.workflows.filter((workflow) => workflow.status === "active").map((workflow) => {
+  const selected = input.workflows.filter((workflow) => workflow.status === "active" && (!input.agent || workflow.compatibleAgents.includes(input.agent))).map((workflow) => {
     const match2 = taskScore(workflow, input.task);
     const cautions = input.store && input.projectId ? input.store.recentFailureCautions(input.projectId, workflow.id) : [];
     return {
@@ -148269,7 +148402,7 @@ async function selectWorkspaceWorkflows(input) {
     errors: synced.errors
   };
 }
-var KNOWN_AGENTS, WORKFLOW_ADAPTER_TARGETS, STATUS_VALUES, LENS_TERMS, GENERIC_WORKFLOW_LENSES, GENERIC_WORKFLOW_TERMS;
+var WORKFLOW_AGENT_TARGETS, WORKFLOW_ADAPTER_TARGETS, STATUS_VALUES, LENS_TERMS, GENERIC_WORKFLOW_LENSES, GENERIC_WORKFLOW_TERMS;
 var init_workflows2 = __esm({
   "src/knowledge/workflows.ts"() {
     "use strict";
@@ -148281,7 +148414,7 @@ var init_workflows2 = __esm({
     init_workflow_store();
     init_outcome_store();
     init_task_lens();
-    KNOWN_AGENTS = [
+    WORKFLOW_AGENT_TARGETS = [
       "windsurf",
       "cursor",
       "claude-code",

package/docs/1.2.4-PERSISTENT-MEMORY-DELIVERY.md

@@ -26,7 +26,7 @@ database, a transcript archive, or another default MCP tool.
 | Start a new, unrelated task | A bounded task Workset. No automatic prior-session text. |
 | Continue or take over prior work | The same Workset plus a bounded prior-work projection. |
 | MCP is available | Use the existing `memorix_project_context` tool with the real task. |
-| MCP is unavailable | Make one CLI call: `memorix resume "<task>" --json` for continuation or `memorix context "<task>" --json` for a new task. |
+| MCP is unavailable | Make one CLI call: `memorix resume "<task>" --brief-json` for continuation or `memorix context "<task>" --brief-json` for a new task. `--json` remains the detailed diagnostic form. |
 | Claude Code hook is installed | An explicit continuation prompt receives the same bounded prior-work Workset through the official `UserPromptSubmit` context channel, unless `memory.inject = "silent"`. |
 | Read-only assessment | The brief may be read, but Memorix does not persist a new observation unless the user explicitly asks to save one. |
 | Need a deliberate session handoff | Keep using the explicit session/handoff surfaces; this projection does not replace them. |

package/docs/API_REFERENCE.md

@@ -115,7 +115,7 @@ MCP:
 - `memorix_context_pack` builds a task-specific packet with reliable current memories, lower-trust unbound memories, current code facts, freshness warnings, suggested reads, and suggested verification.
 - `memorix_graph_context` is an advanced compact graph overview. It starts from a small task-matched baseline and can add only directly related, evidence-governed memories. Its `Graph evidence` section includes relation provenance rather than recursively dumping graph neighbors.
 
-`memorix context` defaults to `--refresh auto`, so first use can seed Code State without a separate manual `memorix codegraph refresh`. Its brief puts live package/changelog/Git facts before memory hints and flags an old `ACTIVE_WORK.md`, legacy `progress.txt`, or legacy dev-log note as historical when it predates the latest changelog, so agents should treat current facts as the source of truth when files disagree. Task lenses keep the packet shaped to the work: bugfix briefs prefer failing tests and repros, release briefs prefer metadata/changelog/package checks, and onboarding briefs prefer docs and entry points while hiding unrelated suspect details. Continuation delivery is separate from the task lens: continuation language in `memorix_project_context` enables a bounded prior-work projection, and `memorix resume "..."` makes that choice explicit. It includes only the latest useful session summary, up to three readable durable memories, and at most one recent source-labelled compact checkpoint. Checkpoints are host lifecycle evidence, not durable memory or transcript backups; ordinary new tasks do not receive historical-session context. A completed MCP brief is the default retrieval boundary: search, detail, or Context Pack should expand it only for a named missing fact or an explicit request for deeper history. Use `--refresh never` for read-only inspection and `--refresh always` when you want to force a fresh scan.
+`memorix context` defaults to `--refresh auto`, so first use can seed Code State without a separate manual `memorix codegraph refresh`. Its brief puts live package/changelog/Git facts before memory hints and flags an old `ACTIVE_WORK.md`, legacy `progress.txt`, or legacy dev-log note as historical when it predates the latest changelog, so agents should treat current facts as the source of truth when files disagree. Use `--brief-json` for the same bounded brief plus a receipt of selected and omitted evidence; `--json` remains the detailed legacy diagnostic form. Task lenses keep the packet shaped to the work: bugfix briefs prefer failing tests and repros, release briefs prefer metadata/changelog/package checks, and onboarding briefs prefer docs and entry points while hiding unrelated suspect details. Continuation delivery is separate from the task lens: continuation language in `memorix_project_context` enables a bounded prior-work projection, and `memorix resume "..."` makes that choice explicit. It includes only the latest useful session summary, up to three readable durable memories, and at most one recent source-labelled compact checkpoint. Checkpoints are host lifecycle evidence, not durable memory or transcript backups; ordinary new tasks do not receive historical-session context. A completed MCP brief is the default retrieval boundary: search, detail, or Context Pack should expand it only for a named missing fact or an explicit request for deeper history. Use `--refresh never` for read-only inspection and `--refresh always` when you want to force a fresh scan.
 
 Project-specific generated, vendored, or cache paths can be excluded from Code State with `[codegraph].exclude_patterns` in `memorix.toml` or `~/.memorix/config.toml` (`codegraph.excludePatterns` in legacy YAML). User patterns extend the built-in excludes and are applied to indexing, Project Context suggested reads, and Context Pack suggested reads.
 

package/docs/DEVELOPMENT.md

@@ -326,9 +326,11 @@ Notes:
 - `server.json` is the official MCP Registry record. Keep it synchronized with
   `package.json` by running `npm run sync:mcp-registry`; verify it with
   `npm run check:mcp-registry` before a release.
-- The GitHub publish workflow publishes npm first, then uses GitHub OIDC to
-  publish the same verified version to the official MCP Registry. It does not
-  require a Registry token or private key in repository secrets.
+- The GitHub publish workflow can publish npm first, then uses GitHub OIDC to
+  publish the same verified version to the official MCP Registry. When npm was
+  already published manually, run the workflow with `publish_npm=false` to
+  publish only the Registry record. It does not require a Registry token or
+  private key in repository secrets.
 - `@memorix/ai`, `@memorix/agent-core`, `@memorix/tui`, and `@memorix/memcode` are internal workspaces. Their code is bundled into the root `memorix` distribution and they must stay `private` unless the project deliberately establishes an owned npm scope and a separate package-support contract.
 - npm publish is usually manual, especially when 2FA is enabled
 - GitHub release automation should not be treated as a substitute for manual runtime validation

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memorix",
   "mcpName": "io.github.AVIDS2/memorix",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Local-first shared memory layer for AI coding agents across MCP clients, Git history, reasoning context, and project sessions.",
   "type": "module",
   "sideEffects": false,

package/plugins/claude/memorix/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "memorix",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Shared workspace memory for Claude Code and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/codebuddy/memorix/.codebuddy-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Local-first project memory for CodeBuddy Code and other coding agents.",
   "author": {
     "name": "AVIDS2",

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

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

package/plugins/copilot/memorix/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Shared local workspace memory for GitHub Copilot CLI and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/gemini/memorix/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "mcpServers": {
     "memorix": {
       "command": "memorix",

package/plugins/omp/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-omp-package",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "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.5.0",
+  "version": "1.6.0",
   "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.5.0",
+  "version": "1.6.0",
   "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.5.0",
+  "version": "1.6.0",
   "websiteUrl": "https://github.com/AVIDS2/memorix#readme",
   "icons": [
     {
@@ -22,7 +22,7 @@
     {
       "registryType": "npm",
       "identifier": "memorix",
-      "version": "1.5.0",
+      "version": "1.6.0",
       "runtimeHint": "npx",
       "packageArguments": [
         {

package/src/cli/commands/codegraph.ts

@@ -5,11 +5,14 @@ import { assembleContextPackForTask, attachTaskWorkset, buildContextPackPrompt }
 import { backfillMissingObservationCodeRefs } from '../../codegraph/binder.js';
 import { collectCurrentProjectFacts, formatGitFact } from '../../codegraph/current-facts.js';
 import { resolveTaskLens } from '../../codegraph/task-lens.js';
-import { getExternalCodeGraphContext, inspectExternalCodeGraph } from '../../codegraph/external-provider.js';
+import { getExternalCodeGraphContext, inspectExternalCodeGraph, runExternalCodeGraphLifecycle } from '../../codegraph/external-provider.js';
 import type { CodeGraphProviderQuality } from '../../codegraph/types.js';
 import { getResolvedConfig } from '../../config/resolved-config.js';
+import { buildBoundedContextReceipt } from '../../knowledge/context-receipt.js';
+import { WORKFLOW_AGENT_TARGETS } from '../../knowledge/workflows.js';
 import { getAllObservations } from '../../memory/observations.js';
 import { filterReadableObservations } from '../../memory/visibility.js';
+import type { AgentTarget } from '../../types.js';
 import { emitError, emitResult, getCliProjectContext, parsePositiveInt } from './operator-shared.js';
 
 function formatSnapshotStatus(status: ReturnType<CodeGraphStore['status']>): string[] {
@@ -48,6 +51,7 @@ function formatStatus(status: ReturnType<CodeGraphStore['status']>, quality?: Co
         `- Persistent provider: ${status.provider} (heuristic local index)`,
         `- External semantic CodeGraph: ${quality.external.state}`
           + (quality.external.reason ? ` (${quality.external.reason})` : ''),
+        `- Task-scoped provider: ${quality.selected} (${quality.selectedQuality})`,
       ]
       : []),
   ].join('\n');
@@ -57,6 +61,8 @@ function formatUsageHint(): string {
   return [
     'Usage:',
     '  memorix codegraph refresh',
+    '  memorix codegraph init       # explicit local CodeGraph initialization',
+    '  memorix codegraph sync       # explicit local CodeGraph synchronization',
     '  memorix codegraph status --json',
     '  memorix codegraph diff [--from <snapshot>] [--to <snapshot>]',
     '  memorix codegraph impact --path <relative-source-path>',
@@ -116,25 +122,34 @@ function compactFacts(project: { rootPath: string }): { facts: string[]; dirty:
   return { facts, dirty: current.git.dirty };
 }
 
+function coerceAgentTarget(input?: string): AgentTarget | undefined {
+  const value = input?.trim().toLowerCase();
+  if (!value) return undefined;
+  if (WORKFLOW_AGENT_TARGETS.includes(value as AgentTarget)) return value as AgentTarget;
+  throw new Error('agent must be one of: ' + WORKFLOW_AGENT_TARGETS.join(', '));
+}
+
 export default defineCommand({
   meta: {
     name: 'codegraph',
     description: 'Inspect and refresh CodeGraph Memory for the current project',
   },
   args: {
-    action: { type: 'string', description: 'Action: status, refresh, diff, impact, or context-pack' },
+    action: { type: 'string', description: 'Action: status, refresh, diff, impact, init, sync, or context-pack' },
     task: { type: 'string', description: 'Task text for context-pack' },
     path: { type: 'string', description: 'Indexed relative source path for impact' },
     limit: { type: 'string', description: 'Max active memories to inspect for context-pack' },
     from: { type: 'string', description: 'Earlier CodeGraph snapshot id for diff' },
     to: { type: 'string', description: 'Later CodeGraph snapshot id for diff' },
     impactLimit: { type: 'string', description: 'Maximum graph relations to inspect for diff impact' },
+    agent: { type: 'string', description: 'Optional target agent for compatible workflow selection' },
     json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+    briefJson: { type: 'boolean', description: 'Emit only the bounded agent brief and receipt JSON for context-pack' },
   },
   run: async ({ args }) => {
     const positional = (args._ as string[]) ?? [];
     const action = (positional[0] || (args.action as string | undefined) || 'status').toLowerCase();
-    const asJson = !!args.json;
+    const asJson = !!args.json || !!args.briefJson;
 
     try {
       const { project, dataDir, reader } = await getCliProjectContext();
@@ -206,6 +221,27 @@ export default defineCommand({
           return;
         }
 
+        case 'init':
+        case 'sync': {
+          const lifecycle = await runExternalCodeGraphLifecycle({
+            action,
+            projectRoot: project.rootPath,
+            mode: codegraphConfig.externalContext,
+            command: codegraphConfig.externalCommand,
+            timeoutMs: codegraphConfig.externalTimeoutMs,
+          });
+          emitResult(
+            { project, lifecycle, providerQuality: lifecycle.quality },
+            [
+              lifecycle.message,
+              `- External semantic CodeGraph: ${lifecycle.health.state}`,
+              `- Task-scoped provider: ${lifecycle.quality.selected} (${lifecycle.quality.selectedQuality})`,
+            ].join('\n'),
+            asJson,
+          );
+          return;
+        }
+
         case 'diff': {
           const snapshots = store.listSnapshots(project.id, 2);
           const fromSnapshotId = (args.from as string | undefined)?.trim() || snapshots[1]?.id;
@@ -299,13 +335,20 @@ export default defineCommand({
               ? { runtimeCautions: [{ kind: 'external-codegraph-fallback' as const, message: external.caution }] }
               : {}),
             reader,
+            agent: coerceAgentTarget(args.agent as string | undefined),
           });
-          emitResult({ project, pack, providerQuality: external.quality }, buildContextPackPrompt(pack), asJson);
+          emitResult(
+            args.briefJson && pack.workset
+              ? buildBoundedContextReceipt({ workset: pack.workset, providerQuality: external.quality })
+              : { project, pack, providerQuality: external.quality },
+            buildContextPackPrompt(pack),
+            asJson,
+          );
           return;
         }
 
         default:
-          emitError(`unknown codegraph action "${action}". Use "status", "refresh", "diff", "impact", or "context-pack".`, asJson);
+          emitError(`unknown codegraph action "${action}". Use "status", "refresh", "init", "sync", "diff", "impact", or "context-pack".`, asJson);
       }
     } catch (error) {
       emitError(error instanceof Error ? error.message : String(error), asJson);