memorix 1.5.0 → 1.6.0

package/dist/index.js

@@ -3987,6 +3987,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)) {
@@ -3999,37 +4001,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((resolve2, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(abortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve2(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+async function waitForRetry(waitMs, signal) {
+  if (!signal) {
     await new Promise((resolve2) => setTimeout(resolve2, 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((resolve2, 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);
+      resolve2();
+    }
+    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";
@@ -4048,6 +4112,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;
@@ -4259,15 +4331,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;
@@ -5131,22 +5202,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",
@@ -5163,10 +5235,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 ? {
@@ -5175,11 +5247,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",
@@ -5197,10 +5270,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 ? {
@@ -5705,6 +5778,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((resolve2, 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();
+        resolve2(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";
@@ -6569,16 +6693,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;
@@ -144998,7 +145124,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 {
@@ -148726,6 +148858,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,
@@ -148791,7 +148924,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]);
   }
@@ -149067,7 +149200,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 {
@@ -149347,7 +149480,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";
@@ -149359,7 +149492,7 @@ var init_workflows2 = __esm({
     init_workflow_store();
     init_outcome_store();
     init_task_lens();
-    KNOWN_AGENTS = [
+    WORKFLOW_AGENT_TARGETS = [
       "windsurf",
       "cursor",
       "claude-code",
@@ -155333,13 +155466,13 @@ function verifyType(declaredType, narrative, title) {
   }
   return { type: declaredType, corrected: false };
 }
-async function extractFactsWithLLM(narrative, title, existingFacts) {
+async function extractFactsWithLLM(narrative, title, existingFacts, signal) {
   try {
     const { callLLM: callLLM2 } = await Promise.resolve().then(() => (init_provider2(), provider_exports2));
     const input = `Title: ${title}
 Content: ${narrative}${existingFacts.length > 0 ? `
 Already known facts (don't repeat): ${existingFacts.join("; ")}` : ""}`;
-    const response = await callLLM2(LLM_EXTRACT_PROMPT, input);
+    const response = await callLLM2(LLM_EXTRACT_PROMPT, input, signal);
     const text2 = response.content.trim();
     const jsonMatch = text2.match(/\{[\s\S]*\}/);
     if (!jsonMatch) return [];
@@ -155348,15 +155481,16 @@ Already known facts (don't repeat): ${existingFacts.join("; ")}` : ""}`;
     if (!Array.isArray(facts)) return [];
     const existingLower = new Set(existingFacts.map((f3) => f3.toLowerCase().trim()));
     return facts.filter((f3) => typeof f3 === "string" && f3.length >= 5).filter((f3) => !existingLower.has(f3.toLowerCase().trim())).slice(0, 10);
-  } catch {
+  } catch (error) {
+    if (signal?.aborted) throw error;
     return [];
   }
 }
-async function runExtract(input, existingEntities, useLLM = false) {
+async function runExtract(input, existingEntities, useLLM = false, signal) {
   const callerFacts = input.facts ?? [];
   let extractedFacts;
   if (useLLM) {
-    extractedFacts = await extractFactsWithLLM(input.narrative, input.title, callerFacts);
+    extractedFacts = await extractFactsWithLLM(input.narrative, input.title, callerFacts, signal);
     if (extractedFacts.length === 0) {
       extractedFacts = extractFacts2(input.narrative, callerFacts);
     }
@@ -155576,7 +155710,7 @@ function mergeFacts2(oldFacts, newFacts) {
   }
   return merged;
 }
-async function resolveWithLLM(extracted, hits, getObservation2) {
+async function resolveWithLLM(extracted, hits, getObservation2, signal) {
   try {
     const { callLLM: callLLM2 } = await Promise.resolve().then(() => (init_provider2(), provider_exports2));
     const existingMemories = hits.slice(0, 5).map((h2, i2) => ({
@@ -155593,7 +155727,7 @@ Facts: ${extracted.facts.join("; ")}
 
 EXISTING MEMORIES:
 ${existingMemories.map((m2) => `[ID:${m2.id}] ${m2.title} | ${m2.content} | Facts: ${m2.facts}`).join("\n")}`;
-    const response = await callLLM2(LLM_RESOLVE_PROMPT, input);
+    const response = await callLLM2(LLM_RESOLVE_PROMPT, input, signal);
     const text2 = response.content.trim();
     const jsonMatch = text2.match(/\{[\s\S]*\}/);
     if (!jsonMatch) return null;
@@ -155630,7 +155764,8 @@ ${existingMemories.map((m2) => `[ID:${m2.id}] ${m2.title} | ${m2.content} | Fact
       };
     }
     return null;
-  } catch {
+  } catch (error) {
+    if (signal?.aborted) throw error;
     return null;
   }
 }
@@ -155648,19 +155783,20 @@ function scoreCandidate(extracted, candidate) {
   const contradiction = hasContradiction(candidate.narrative, extracted.narrative);
   return { score, searchSimilarity, entityMatch, richer, contradiction };
 }
-async function runResolve(extracted, projectId, searchMemories, getObservation2, useLLM = false) {
+async function runResolve(extracted, projectId, searchMemories, getObservation2, useLLM = false, signal) {
   const query = `${extracted.title} ${extracted.narrative.substring(0, 200)}`;
   let hits;
   try {
-    hits = await searchMemories(query, 5, projectId);
-  } catch {
+    hits = await searchMemories(query, 5, projectId, signal);
+  } catch (error) {
+    if (signal?.aborted) throw error;
     return { action: "new", reason: "Search unavailable, defaulting to new" };
   }
   if (hits.length === 0) {
     return { action: "new", reason: "No similar existing memories found" };
   }
   if (useLLM) {
-    const llmResult = await resolveWithLLM(extracted, hits, getObservation2);
+    const llmResult = await resolveWithLLM(extracted, hits, getObservation2, signal);
     if (llmResult) return llmResult;
   }
   const scored = hits.map((hit) => ({
@@ -156082,7 +156218,7 @@ async function runFormation(input, config) {
   const existingEntities = config.getEntityNames();
   const extractStartTime = Date.now();
   emitStageEvent("extract", "start");
-  const extraction = await runExtract(input, existingEntities, config.useLLM);
+  const extraction = await runExtract(input, existingEntities, config.useLLM, config.signal);
   stageDurationsMs.extract = Date.now() - extractStartTime;
   emitStageEvent("extract", "success", stageDurationsMs.extract);
   stagesCompleted = 1;
@@ -156102,7 +156238,8 @@ async function runFormation(input, config) {
       input.projectId,
       config.searchMemories,
       config.getObservation,
-      config.useLLM
+      config.useLLM,
+      config.signal
     );
     stageDurationsMs.resolve = Date.now() - resolveStartTime;
     emitStageEvent("resolve", "success", stageDurationsMs.resolve);
@@ -156991,6 +157128,15 @@ function workflowOutput(selection) {
     cautions: selection.cautions.map((caution) => short(caution, 22))
   };
 }
+function workflowLoadout(agent, selections) {
+  if (!agent) return void 0;
+  return {
+    agent,
+    workflowIds: selections.map((selection) => selection.workflow.id),
+    requiredContext: unique(selections.flatMap((selection) => selection.workflow.requiredContext)).map((item) => short(item, 18)).slice(0, 4),
+    allowedTools: unique(selections.flatMap((selection) => selection.workflow.allowedTools)).map((item) => short(item, 12)).slice(0, 6)
+  };
+}
 function appendLine(lines, candidate, maxTokens, omitted, omittedKind, selected, receiptSelection) {
   const next = lines.length ? lines.join("\n") + "\n" + candidate : candidate;
   if (countTextTokens(next) <= maxTokens) {
@@ -157451,6 +157597,22 @@ function renderTaskWorksetPrompt(input) {
       );
     }
   }
+  if (input.agentLoadout) {
+    appendLine(lines, "", maxTokens, omitted, "agent-loadout-heading");
+    appendLine(lines, "Agent loadout (" + input.agentLoadout.agent + ")", maxTokens, omitted, "agent-loadout-heading");
+    for (const required of input.agentLoadout.requiredContext.slice(0, 2)) {
+      appendLine(lines, "- Need: " + required, maxTokens, omitted, "agent-loadout-context");
+    }
+    if (input.agentLoadout.allowedTools.length > 0) {
+      appendLine(
+        lines,
+        "- Workflow tools: " + input.agentLoadout.allowedTools.join(", "),
+        maxTokens,
+        omitted,
+        "agent-loadout-tools"
+      );
+    }
+  }
   if (input.verification.length > 0) {
     appendLine(lines, "", maxTokens, omitted, "verification-heading");
     appendLine(lines, "Verify", maxTokens, omitted, "verification-heading");
@@ -157542,6 +157704,7 @@ async function buildTaskWorkset(input) {
   let workspace;
   let pages = [];
   let workflows = [];
+  let workflowSelections = [];
   try {
     workspace = await preferredWorkspace(input.projectId, input.dataDir);
     if (workspace) {
@@ -157558,14 +157721,15 @@ async function buildTaskWorkset(input) {
       if (task) {
         const workflowStore = new WorkflowStore();
         await workflowStore.init(input.dataDir);
-        const selected = selectWorkflows({
+        workflowSelections = selectWorkflows({
           workflows: workflowStore.listWorkflows(workspace.id, "active"),
           task,
           projectId: input.projectId,
           store: workflowStore,
+          ...input.agent ? { agent: input.agent } : {},
           limit: 2
         });
-        workflows = selected.map(workflowOutput);
+        workflows = workflowSelections.map(workflowOutput);
         for (const workflow of workflows) {
           for (const caution of workflow.cautions) {
             cautions.push({ kind: "workflow-failed-verification", message: caution });
@@ -157587,6 +157751,10 @@ async function buildTaskWorkset(input) {
     workflows
   });
   const governedDurableIds = new Set(governed.durableMemory.map((memory) => memory.id));
+  const agentLoadout = workflowLoadout(
+    input.agent,
+    workflowSelections.filter((selection2) => governed.workflows.some((workflow) => workflow.id === selection2.workflow.id))
+  );
   const evidenceIds = unique(governed.claims.flatMap((claim) => evidenceIdsForClaim(
     claim,
     evidenceByClaim.get(claim.id) ?? []
@@ -157631,6 +157799,7 @@ async function buildTaskWorkset(input) {
     pages: pages.filter((page) => page.claimIds.some((claimId) => governed.claims.some((claim) => claim.id === claimId))),
     durableMemory: governed.durableMemory,
     workflows: governed.workflows,
+    ...agentLoadout ? { agentLoadout } : {},
     cautions: normalizedCautions,
     verification,
     evidenceIds,
@@ -157849,10 +158018,12 @@ var init_current_facts = __esm({
 var external_provider_exports = {};
 __export(external_provider_exports, {
   DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS: () => DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS,
+  EXTERNAL_CODEGRAPH_LIFECYCLE_TIMEOUT_MS: () => EXTERNAL_CODEGRAPH_LIFECYCLE_TIMEOUT_MS,
   MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES: () => MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES,
   MAX_EXTERNAL_CODEGRAPH_TIMEOUT_MS: () => MAX_EXTERNAL_CODEGRAPH_TIMEOUT_MS,
   getExternalCodeGraphContext: () => getExternalCodeGraphContext,
-  inspectExternalCodeGraph: () => inspectExternalCodeGraph
+  inspectExternalCodeGraph: () => inspectExternalCodeGraph,
+  runExternalCodeGraphLifecycle: () => runExternalCodeGraphLifecycle
 });
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync15, readFileSync as readFileSync10 } from "fs";
@@ -158051,6 +158222,66 @@ async function inspectExternalCodeGraph(input) {
   const health = healthFromStatus(status);
   return { health, quality: providerQuality({ mode, health }) };
 }
+async function runExternalCodeGraphLifecycle(input) {
+  const mode = input.mode ?? "auto";
+  if (mode === "off") {
+    const health = { state: "disabled", reason: "External CodeGraph is disabled by configuration." };
+    return {
+      action: input.action,
+      performed: false,
+      message: "External CodeGraph is disabled by configuration.",
+      health,
+      quality: providerQuality({ mode, health })
+    };
+  }
+  const indexPath = join20(input.projectRoot, ".codegraph");
+  if (input.action === "sync" && !existsSync15(indexPath)) {
+    const health = { state: "not-detected", reason: "No local .codegraph index is present for this project." };
+    return {
+      action: input.action,
+      performed: false,
+      message: 'Initialize CodeGraph first with "memorix codegraph init".',
+      health,
+      quality: providerQuality({ mode, health })
+    };
+  }
+  if (input.action === "init" && existsSync15(indexPath)) {
+    const inspected2 = await inspectExternalCodeGraph(input);
+    return {
+      action: input.action,
+      performed: false,
+      message: "A local CodeGraph directory already exists; no initialization was performed.",
+      ...inspected2
+    };
+  }
+  const result = await runSafely(input.runner ?? defaultRunner, {
+    command: input.command,
+    args: input.action === "init" ? ["init", input.projectRoot] : ["sync", input.projectRoot, "--quiet"],
+    cwd: input.projectRoot,
+    // A context read must stay fast; an explicit user-requested index sync is
+    // a different operation and gets its own bounded maintenance window.
+    timeoutMs: EXTERNAL_CODEGRAPH_LIFECYCLE_TIMEOUT_MS,
+    maxOutputBytes: MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES
+  });
+  if (!result.ok) {
+    const health = unavailableHealth(result);
+    return {
+      action: input.action,
+      performed: false,
+      message: "CodeGraph " + input.action + " did not complete: " + (health.reason ?? "unknown local error"),
+      health,
+      quality: providerQuality({ mode, health })
+    };
+  }
+  const inspected = await inspectExternalCodeGraph(input);
+  const remainsStale = inspected.health.state === "stale";
+  return {
+    action: input.action,
+    performed: true,
+    message: input.action === "init" ? 'Local CodeGraph initialization completed. Run "memorix codegraph sync" when source changes.' : remainsStale ? "Local CodeGraph synchronization completed, but the graph remains stale against the current worktree; this task will use Lite evidence." : "Local CodeGraph synchronization completed and is ready for task-scoped semantic context.",
+    ...inspected
+  };
+}
 function safeRelativePath(projectRoot, value, exclude) {
   const path37 = safeText(value, 1024);
   if (!path37 || isAbsolute(path37)) return void 0;
@@ -158176,7 +158407,7 @@ async function getExternalCodeGraphContext(input) {
     quality: providerQuality({ mode, health: inspected.health, ...contributes ? { selected: "external" } : {} })
   };
 }
-var DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS, MAX_EXTERNAL_CODEGRAPH_TIMEOUT_MS, MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES, MAX_EXTERNAL_NODE_COUNT, MAX_EXTERNAL_EDGE_COUNT, MAX_EXTERNAL_FILE_COUNT, MAX_EXTERNAL_TEXT_LENGTH, LITE_SUPPORTED_LANGUAGES, defaultRunner;
+var DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS, MAX_EXTERNAL_CODEGRAPH_TIMEOUT_MS, EXTERNAL_CODEGRAPH_LIFECYCLE_TIMEOUT_MS, MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES, MAX_EXTERNAL_NODE_COUNT, MAX_EXTERNAL_EDGE_COUNT, MAX_EXTERNAL_FILE_COUNT, MAX_EXTERNAL_TEXT_LENGTH, LITE_SUPPORTED_LANGUAGES, defaultRunner;
 var init_external_provider = __esm({
   "src/codegraph/external-provider.ts"() {
     "use strict";
@@ -158186,6 +158417,7 @@ var init_external_provider = __esm({
     init_ids();
     DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS = 1200;
     MAX_EXTERNAL_CODEGRAPH_TIMEOUT_MS = 5e3;
+    EXTERNAL_CODEGRAPH_LIFECYCLE_TIMEOUT_MS = 3e4;
     MAX_EXTERNAL_CODEGRAPH_OUTPUT_BYTES = 256 * 1024;
     MAX_EXTERNAL_NODE_COUNT = 16;
     MAX_EXTERNAL_EDGE_COUNT = 24;
@@ -159011,6 +159243,7 @@ async function buildAutoProjectContext(input) {
     projectId: input.project.id,
     dataDir: input.dataDir,
     ...task ? { task } : {},
+    ...input.agent ? { agent: input.agent } : {},
     lens: lens.id,
     startHere,
     ...alwaysOn.profile.length > 0 || alwaysOn.state || alwaysOn.durable.length > 0 ? { alwaysOn } : {},
@@ -159347,6 +159580,34 @@ var init_auto_context = __esm({
   }
 });
 
+// src/knowledge/context-receipt.ts
+var context_receipt_exports = {};
+__export(context_receipt_exports, {
+  buildBoundedContextReceipt: () => buildBoundedContextReceipt
+});
+function buildBoundedContextReceipt(input) {
+  const provider2 = input.providerQuality ?? input.workset.provenance.codeProvider;
+  return {
+    schemaVersion: "1",
+    task: input.workset.task,
+    brief: input.workset.prompt,
+    receipt: input.workset.receipt,
+    code: {
+      selected: provider2?.selected ?? "lite",
+      quality: provider2?.selectedQuality ?? "heuristic",
+      externalState: provider2?.external.state ?? "not-detected",
+      ...input.workset.provenance.snapshotId ? { snapshotId: input.workset.provenance.snapshotId } : {}
+    },
+    ...input.workset.agentLoadout ? { loadout: input.workset.agentLoadout } : {}
+  };
+}
+var init_context_receipt = __esm({
+  "src/knowledge/context-receipt.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/codegraph/context-pack.ts
 var context_pack_exports = {};
 __export(context_pack_exports, {
@@ -159505,6 +159766,7 @@ async function attachTaskWorkset(input) {
     projectId: input.projectId,
     dataDir: input.dataDir,
     task: input.pack.task,
+    ...input.agent ? { agent: input.agent } : {},
     lens: input.lens,
     currentFacts: input.currentFacts ?? [],
     ...input.codeState ? { codeState: input.codeState } : {},
@@ -163897,8 +164159,8 @@ var init_official_skills = __esm({
           "",
           "| Situation | Prefer | CLI fallback |",
           "|---|---|---|",
-          '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --json` |',
-          '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --json` |',
+          '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --brief-json` |',
+          '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --brief-json` |',
           '| Need structured refs/freshness for code-bound memories | `memorix_context_pack` | `memorix codegraph context-pack --task "<topic>"` |',
           '| Explicit memory graph question | `memorix_graph_context` | `memorix memory graph-context --query "<topic>"` |',
           '| Specific past decision, bug, file, or change | `memorix_search` | `memorix memory search --query "<topic>"` |',
@@ -163911,7 +164173,7 @@ var init_official_skills = __esm({
           "",
           "- Default first step for non-trivial coding work: call `memorix_project_context` before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Pass the user's actual task so Memorix can choose a bugfix, feature, release, onboarding, refactor, docs, test, or general brief. Start by reading its suggested files.",
           "- In Claude Code headless/print-mode, an initial MCP `pending` status is not a failure by itself. Prefer MCP first: use the client's tool discovery/dynamic loading to find `memorix_project_context` when it is not in the first visible tool list.",
-          '- Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run `memorix resume "<task>" --json` exactly once before inspecting files, Git history, progress notes, or guessing. The absence of `.memorix` or visible memory files never proves project memory is empty. For a new task, use `memorix context "<task>" --json` instead. If that one command fails, report it and proceed normally; do not probe help, enumerate commands, or chain broad searches.',
+          '- Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run `memorix resume "<task>" --brief-json` exactly once before inspecting files, Git history, progress notes, or guessing. The absence of `.memorix` or visible memory files never proves project memory is empty. For a new task, use `memorix context "<task>" --brief-json` instead. Use `--json` only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally; do not probe help, enumerate commands, or chain broad searches.',
           "- After a successful `memorix_project_context`, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use Context Pack, search, or detail only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.",
           "- If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.",
           "- Use `memorix_search` for a specific decision, bug, file, or prior change that the project context did not answer. Fetch detail only for a result you still need after the brief.",
@@ -165170,7 +165432,7 @@ alwaysApply: true
     "",
     `Default first step for non-trivial coding work: call \`memorix_project_context\` with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). When the task is continuing prior work, the same brief also includes a bounded prior-work projection. Treat its "Start here" files as the first ${contextNoun} files to inspect.`,
     "",
-    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user\'s real task before inspecting files, Git history, progress notes, or guessing: `memorix resume "<task>" --json`. For a new task, use `memorix context "<task>" --json` instead. The absence of `.memorix` or visible memory files never proves project memory is empty. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
+    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user\'s real task before inspecting files, Git history, progress notes, or guessing: `memorix resume "<task>" --brief-json`. For a new task, use `memorix context "<task>" --brief-json` instead. The absence of `.memorix` or visible memory files never proves project memory is empty. Use `--json` only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
     "",
     "After a successful `memorix_project_context` result, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use `memorix_context_pack`, `memorix_search`, or `memorix_detail` only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.",
     "If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.",
@@ -165834,7 +166096,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.5.0" : "1.0.1"
+    version: true ? "1.6.0" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -166023,8 +166285,8 @@ The path should point to a directory containing a .git folder.`
                 mode: "active",
                 useLLM: isLLMEnabled(),
                 minValueScore: 0.3,
-                searchMemories: async (q, limit2, pid) => {
-                  const result = await compactSearch({ query: q, limit: limit2, projectId: pid, status: "active", reader });
+                searchMemories: async (q, limit2, pid, signal) => {
+                  const result = await compactSearch({ query: q, limit: limit2, projectId: pid, status: "active", reader, signal });
                   if (result.entries.length === 0) return [];
                   const details = await compactDetail(result.entries.map((e2) => e2.id), { reader });
                   return details.documents.map((d, i2) => ({
@@ -166054,16 +166316,19 @@ The path should point to a directory containing a .git folder.`
                 getEntityNames: () => graphManager.getEntityNames(),
                 onStageEvent: onFormationStageEvent
               };
-              formationResult = await withTimeout(
-                runFormation({
-                  entityName,
-                  type,
-                  title,
-                  narrative,
-                  facts: safeFacts,
-                  projectId: project.id,
-                  source: "explicit"
-                }, formationConfig),
+              formationResult = await withTimeoutSignal(
+                async (signal) => {
+                  formationConfig.signal = signal;
+                  return runFormation({
+                    entityName,
+                    type,
+                    title,
+                    narrative,
+                    facts: safeFacts,
+                    projectId: project.id,
+                    source: "explicit"
+                  }, formationConfig);
+                },
                 FORMATION_TIMEOUT_MS,
                 "Formation pipeline"
               );
@@ -166413,8 +166678,8 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                 mode: formationMode,
                 useLLM: isLLMEnabled(),
                 minValueScore: 0.3,
-                searchMemories: async (q, limit2, pid) => {
-                  const result = await compactSearch({ query: q, limit: limit2, projectId: pid, status: "active", reader });
+                searchMemories: async (q, limit2, pid, signal) => {
+                  const result = await compactSearch({ query: q, limit: limit2, projectId: pid, status: "active", reader, signal });
                   if (result.entries.length === 0) return [];
                   const details = await compactDetail(result.entries.map((e2) => e2.id), { reader });
                   return details.documents.map((d, i2) => ({
@@ -166435,8 +166700,11 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                 },
                 getEntityNames: () => graphManager.getEntityNames()
               };
-              const formed = await withTimeout(
-                runFormation({ entityName, type, title, narrative, facts: safeFacts, projectId: project.id, source: "explicit", topicKey }, formationConfig),
+              const formed = await withTimeoutSignal(
+                async (signal) => {
+                  formationConfig.signal = signal;
+                  return runFormation({ entityName, type, title, narrative, facts: safeFacts, projectId: project.id, source: "explicit", topicKey }, formationConfig);
+                },
                 FORMATION_TIMEOUT_MS,
                 "Shadow formation"
               );
@@ -166662,13 +166930,28 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         refresh: z626.enum(["auto", "always", "never"]).optional().default("auto").describe(
           "Code Memory refresh policy. auto refreshes only when missing or stale."
         ),
-        format: z626.enum(["prompt", "summary", "json"]).optional().default("prompt").describe(
-          'Output format. "prompt" is agent-ready; "summary" is human-readable; "json" is structured.'
+        format: z626.enum(["prompt", "summary", "json", "receipt"]).optional().default("prompt").describe(
+          'Output format. "prompt" is agent-ready; "summary" is human-readable; "receipt" is bounded JSON; "json" is detailed diagnostics.'
         ),
+        agent: z626.enum([
+          "windsurf",
+          "cursor",
+          "claude-code",
+          "codex",
+          "copilot",
+          "antigravity",
+          "gemini-cli",
+          "openclaw",
+          "hermes",
+          "omp",
+          "kiro",
+          "opencode",
+          "trae"
+        ]).optional().describe("Optional target agent for compatible workflow selection."),
         limit: z626.number().optional().describe("Reserved for future source limits; current prompt stays compact by default.")
       }
     },
-    async ({ task, refresh, format }) => {
+    async ({ task, refresh, format, agent }) => {
       const unresolved = requireResolvedProject("build project context for the current project");
       if (unresolved) return unresolved;
       const [
@@ -166680,12 +166963,14 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         },
         { getObservationStore: getObservationStore2 },
         { MaintenanceJobStore: MaintenanceJobStore2 },
-        { enqueueCodegraphRefresh: enqueueCodegraphRefresh2 }
+        { enqueueCodegraphRefresh: enqueueCodegraphRefresh2 },
+        { buildBoundedContextReceipt: buildBoundedContextReceipt2 }
       ] = await Promise.all([
         Promise.resolve().then(() => (init_auto_context(), auto_context_exports)),
         Promise.resolve().then(() => (init_obs_store(), obs_store_exports)),
         Promise.resolve().then(() => (init_maintenance_jobs(), maintenance_jobs_exports)),
-        Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports))
+        Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports)),
+        Promise.resolve().then(() => (init_context_receipt(), context_receipt_exports))
       ]);
       const observations2 = filterReadableObservations(
         await getObservationStore2().loadByProject(project.id, { status: "active" }),
@@ -166696,6 +166981,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         dataDir: projectDir2,
         observations: observations2,
         task,
+        agent,
         refresh: refresh ?? "auto",
         reader: getObservationReader(),
         enqueueRefresh: () => {
@@ -166708,7 +166994,10 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
           });
         }
       });
-      const text2 = format === "json" ? JSON.stringify({ ...context, brief: buildAutoProjectBrief2(context) }, null, 2) : format === "summary" ? formatAutoProjectContextSummary2(context) : formatAutoProjectContextPrompt2(context);
+      const text2 = format === "json" ? JSON.stringify({ ...context, brief: buildAutoProjectBrief2(context) }, null, 2) : format === "receipt" ? JSON.stringify(buildBoundedContextReceipt2({
+        workset: context.workset,
+        providerQuality: context.providerQuality
+      }), null, 2) : format === "summary" ? formatAutoProjectContextSummary2(context) : formatAutoProjectContextPrompt2(context);
       autopilotRetrievalBoundary = {
         projectId: project.id,
         issuedAt: Date.now(),
@@ -170213,7 +170502,7 @@ var init_serve_shared = __esm({
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.5.0" : pkg.version;
+  return true ? "1.6.0" : pkg.version;
 }
 var init_version3 = __esm({
   "src/cli/version.ts"() {