memorix 1.9.9 → 1.9.11

package/dist/cli/index.js

@@ -3232,7 +3232,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.9.9" : pkg.version;
+  return true ? "1.9.11" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -13748,9 +13748,9 @@ function sharedAgentIds(record2) {
     return [];
   }
 }
-function canReadObservation(record2, reader2) {
+function canReadObservation(record2, reader2, allowedProjectIds) {
   if (!reader2) return true;
-  const sameProject = reader2.projectId === record2.projectId;
+  const sameProject = allowedProjectIds ? allowedProjectIds.includes(record2.projectId) : reader2.projectId === record2.projectId;
   const visibility = resolveObservationVisibility(record2);
   if (visibility === "project") return !reader2.projectId || sameProject;
   if (!sameProject || !reader2.agentId) return false;
@@ -22144,15 +22144,16 @@ function getResolvedConfig(options = {}) {
   const openRouterMemoryLlmApiKey = isOpenRouterMemoryLane(memoryLlmProvider, memoryLlmBaseUrl) ? process.env.OPENROUTER_API_KEY : void 0;
   const isAtlasCloud = memoryLlmProvider === "atlascloud";
   const isRequesty = memoryLlmProvider === "requesty";
-  const usesPresetKeyOnly = isAtlasCloud || isRequesty;
+  const isApiRoute = memoryLlmProvider === "apiroute";
+  const usesPresetKeyOnly = isAtlasCloud || isRequesty || isApiRoute;
   const memoryLlmApiKey = first(
     process.env.MEMORIX_LLM_API_KEY,
     process.env.MEMORIX_API_KEY,
     toml.memory?.llm?.api_key,
     yaml.llm?.apiKey,
     legacy.llm?.apiKey,
-    // Never borrow another provider's credentials for the Atlas Cloud or Requesty presets.
-    isAtlasCloud ? process.env.ATLASCLOUD_API_KEY : isRequesty ? process.env.REQUESTY_API_KEY : process.env.OPENAI_API_KEY,
+    // Never borrow another provider's credentials for these gateway presets.
+    isAtlasCloud ? process.env.ATLASCLOUD_API_KEY : isRequesty ? process.env.REQUESTY_API_KEY : isApiRoute ? process.env.API_ROUTE_API_KEY : process.env.OPENAI_API_KEY,
     usesPresetKeyOnly ? void 0 : process.env.ANTHROPIC_API_KEY,
     usesPresetKeyOnly ? void 0 : openRouterMemoryLlmApiKey
   );
@@ -22335,6 +22336,7 @@ function getEnvSourceNames() {
     "MEMORIX_CODEGRAPH_EXTERNAL_TIMEOUT_MS",
     "OPENROUTER_API_KEY",
     "REQUESTY_API_KEY",
+    "API_ROUTE_API_KEY",
     "ATLASCLOUD_API_KEY"
   ].filter((name) => process.env[name]);
 }
@@ -25328,6 +25330,7 @@ var init_provider2 = __esm({
       anthropic: { baseUrl: "https://api.anthropic.com/v1", model: "claude-3-5-haiku-latest" },
       openrouter: { baseUrl: "https://openrouter.ai/api/v1", model: "openai/gpt-4.1-nano" },
       requesty: { baseUrl: "https://router.requesty.ai/v1", model: "openai/gpt-4.1-nano" },
+      apiroute: { baseUrl: "https://global.api-route.com/v1", model: "deepseek-v4.1-flash" },
       atlascloud: { baseUrl: "https://api.atlascloud.ai/v1", model: "deepseek-ai/deepseek-v3.2" },
       custom: { baseUrl: "http://localhost:11434/v1", model: "llama3" }
     };
@@ -25822,6 +25825,19 @@ var init_sqlite_store = __esm({
       async listProjectIds() {
         return this.db.prepare("SELECT DISTINCT projectId FROM observations ORDER BY projectId").all().map((row) => row.projectId).filter((projectId) => Boolean(projectId));
       }
+      async migrateProjectIds(aliasIds, canonicalId) {
+        const sourceIds = [...new Set(aliasIds.filter((projectId) => projectId && projectId !== canonicalId))];
+        if (sourceIds.length === 0) return 0;
+        return retrySqliteBusy(async () => {
+          const placeholders = sourceIds.map(() => "?").join(", ");
+          const result = this.db.prepare(
+            `UPDATE observations SET projectId = ? WHERE projectId IN (${placeholders})`
+          ).run(canonicalId, ...sourceIds);
+          const migrated = Number(result.changes ?? 0);
+          if (migrated > 0) this.bumpGeneration();
+          return migrated;
+        }, "Migrate observation project IDs");
+      }
       async searchLexical(options) {
         return searchObservationLexically(this.db, options).map((hit) => ({
           observation: rowToObs(hit.row),
@@ -186704,6 +186720,16 @@ function getProjectObservations(projectId) {
 async function migrateProjectIds(aliasIds, canonicalId) {
   const nonCanonical = new Set(aliasIds.filter((id) => id !== canonicalId));
   if (nonCanonical.size === 0) return 0;
+  const store2 = projectDir ? getObservationStore() : null;
+  if (store2?.migrateProjectIds) {
+    const migrated2 = await store2.migrateProjectIds(aliasIds, canonicalId);
+    if (migrated2 > 0 && corpusLoaded) {
+      for (const observation of observations) {
+        if (nonCanonical.has(observation.projectId)) observation.projectId = canonicalId;
+      }
+    }
+    return migrated2;
+  }
   let migrated = 0;
   const changed = [];
   for (const obs of observations) {
@@ -186714,8 +186740,8 @@ async function migrateProjectIds(aliasIds, canonicalId) {
     }
   }
   if (migrated > 0 && projectDir) {
-    const store2 = getObservationStore();
-    await store2.atomic(async (tx) => {
+    const store3 = getObservationStore();
+    await store3.atomic(async (tx) => {
       await Promise.all(changed.map((observation) => tx.update(observation)));
     });
   }
@@ -187668,6 +187694,7 @@ var orama_store_exports = {};
 __export(orama_store_exports, {
   _classifyQueryTier: () => classifyQueryTier,
   batchGenerateEmbeddings: () => batchGenerateEmbeddings,
+  createSearchTokenizer: () => createSearchTokenizer,
   generateEmbedding: () => generateEmbedding,
   generateEmbeddingInput: () => generateEmbeddingInput,
   getActiveSemanticIndexProfile: () => getActiveSemanticIndexProfile,
@@ -187708,6 +187735,26 @@ function getOptionalObservationStore() {
     return null;
   }
 }
+function createSearchTokenizer() {
+  const defaultTokenizer = components_exports2.tokenizer.createTokenizer({ language: "english" });
+  return {
+    language: defaultTokenizer.language,
+    normalizationCache: defaultTokenizer.normalizationCache,
+    tokenize(raw, language, prop, withCache = true) {
+      const defaultTokens = defaultTokenizer.tokenize(raw, language, prop, withCache);
+      const cjkTokens = [];
+      const normalized = raw.normalize("NFKC").toLowerCase();
+      for (const match2 of normalized.matchAll(CJK_RUN)) {
+        const characters = Array.from(match2[0]);
+        cjkTokens.push(...characters);
+        for (let index = 0; index + 1 < characters.length; index++) {
+          cjkTokens.push(`${characters[index]}${characters[index + 1]}`);
+        }
+      }
+      return [.../* @__PURE__ */ new Set([...defaultTokens, ...cjkTokens])];
+    }
+  };
+}
 async function shouldUsePersistentSearch(projectIds, projectId) {
   const store2 = getOptionalObservationStore();
   if (!store2?.hasLexicalIndex?.()) return false;
@@ -187808,6 +187855,7 @@ async function searchPersistentSemantically(options, projectIds, limit2, queryVe
     const lexical = await searchPersistentLexically(options, projectIds, limit2);
     const store2 = getObservationStore();
     const documents = /* @__PURE__ */ new Map();
+    const vectorDocumentKeys = /* @__PURE__ */ new Map();
     const addObservation = (observation) => {
       const document2 = observationToSearchDocument(observation);
       documents.set(makeEntryKey(document2.projectId, document2.observationId), document2);
@@ -187823,6 +187871,7 @@ async function searchPersistentSemantically(options, projectIds, limit2, queryVe
       if (options.type && observation.type !== options.type) return null;
       if (options.source && observation.source !== options.source) return null;
       addObservation(observation);
+      vectorDocumentKeys.set(hit.observationId, makeEntryKey(observation.projectId, observation.id));
       return observation;
     }));
     const RRF_K = 60;
@@ -187832,7 +187881,7 @@ async function searchPersistentSemantically(options, projectIds, limit2, queryVe
       scores.set(key, (scores.get(key) ?? 0) + 0.6 / (RRF_K + index + 1));
     }
     for (const [index, hit] of vectorHits.entries()) {
-      const key = makeEntryKey(hit.projectId, hit.observationId);
+      const key = vectorDocumentKeys.get(hit.observationId) ?? makeEntryKey(hit.projectId, hit.observationId);
       if (!documents.has(key)) continue;
       scores.set(key, (scores.get(key) ?? 0) + 0.4 / (RRF_K + index + 1));
     }
@@ -187845,12 +187894,13 @@ async function searchPersistentSemantically(options, projectIds, limit2, queryVe
       return {
         count: vectorHits.length,
         hits: vectorHits.map((hit, index) => {
-          const key = makeEntryKey(hit.projectId, hit.observationId);
+          const key = vectorDocumentKeys.get(hit.observationId) ?? makeEntryKey(hit.projectId, hit.observationId);
           const document2 = documents.get(key);
           return document2 ? { id: document2.id, score: 0.4 / (RRF_K + index + 1), document: document2 } : null;
         }).filter((hit) => hit !== null).slice(0, limit2)
       };
     }
+    if (hits.length === 0) return null;
     return { count: hits.length, hits };
   } catch {
     return null;
@@ -187925,7 +187975,10 @@ async function initializeDb(options, generation) {
   };
   const dims = nextEmbeddingDimensions ?? 384;
   const schema = nextEmbeddingEnabled ? { ...baseSchema, embedding: `vector[${dims}]` } : baseSchema;
-  const nextDb = await create5({ schema });
+  const nextDb = await create5({
+    schema,
+    components: { tokenizer: createSearchTokenizer() }
+  });
   if (generation !== dbGeneration) {
     return getDb(options);
   }
@@ -188359,7 +188412,7 @@ async function searchObservations(options) {
     if (!projectIds) return true;
     const doc = hit.document;
     return projectIds.includes(doc.projectId);
-  }).filter((hit) => canReadObservation(hit.document, options.reader)).filter((hit) => {
+  }).filter((hit) => canReadObservation(hit.document, options.reader, projectIds ?? void 0)).filter((hit) => {
     if (statusFilter === "all") return true;
     const doc = hit.document;
     return (doc.status || "active") === statusFilter;
@@ -188625,7 +188678,7 @@ async function searchObservations(options) {
   let entries = intermediate.map(({ rawTime: _5, _isCommandLog: _c, ...rest }) => rest);
   for (const hit of results.hits) {
     const doc = hit.document;
-    if (canReadObservation(doc, options.reader)) rememberObservationDoc(doc);
+    if (canReadObservation(doc, options.reader, projectIds ?? void 0)) rememberObservationDoc(doc);
   }
   if (hasQuery && originalQuery) {
     const queryLower = originalQuery.toLowerCase();
@@ -188783,7 +188836,7 @@ function formatTime(isoDate) {
     return isoDate;
   }
 }
-var db, dbInitPromise, dbGeneration, embeddingEnabled, embeddingDimensions, indexEmbeddingProvider, deferredCachedVectorHydration, NON_CJK_HYBRID_SIMILARITY, lastSearchModeByProject, SEARCH_MODE_DEFAULT_KEY, MAX_SEARCH_MODE_KEYS, COMMAND_LOG_TITLE2, COMMAND_STYLE_TITLE, COMMAND_LIKE_QUERY2, COMMAND_INTENT_QUERY, NATURAL_LANGUAGE_MARKERS;
+var db, dbInitPromise, dbGeneration, embeddingEnabled, embeddingDimensions, indexEmbeddingProvider, deferredCachedVectorHydration, NON_CJK_HYBRID_SIMILARITY, CJK_RUN, lastSearchModeByProject, SEARCH_MODE_DEFAULT_KEY, MAX_SEARCH_MODE_KEYS, COMMAND_LOG_TITLE2, COMMAND_STYLE_TITLE, COMMAND_LIKE_QUERY2, COMMAND_INTENT_QUERY, NATURAL_LANGUAGE_MARKERS;
 var init_orama_store = __esm({
   "src/store/orama-store.ts"() {
     "use strict";
@@ -188808,6 +188861,7 @@ var init_orama_store = __esm({
     indexEmbeddingProvider = null;
     deferredCachedVectorHydration = null;
     NON_CJK_HYBRID_SIMILARITY = 0.45;
+    CJK_RUN = /[\u3400-\u4dbf\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]+/gu;
     lastSearchModeByProject = /* @__PURE__ */ new Map();
     SEARCH_MODE_DEFAULT_KEY = "__global__";
     MAX_SEARCH_MODE_KEYS = 4096;
@@ -193112,6 +193166,8 @@ function buildInitTomlConfig(options) {
       lines.push('# model = "openai/gpt-4o-mini"');
     } else if (options.llmProvider === "requesty") {
       lines.push('# model = "openai/gpt-4o-mini"');
+    } else if (options.llmProvider === "apiroute") {
+      lines.push('model = "deepseek-v4.1-flash"');
     } else if (options.llmProvider === "atlascloud") {
       lines.push('model = "deepseek-ai/deepseek-v3.2"');
     }
@@ -193247,6 +193303,7 @@ var init_init = __esm({
             { value: "anthropic", label: "Anthropic", hint: "claude-3-haiku" },
             { value: "openrouter", label: "OpenRouter", hint: "multi-provider" },
             { value: "requesty", label: "Requesty", hint: "multi-provider" },
+            { value: "apiroute", label: "API Route", hint: "multi-provider" },
             { value: "atlascloud", label: "Atlas Cloud", hint: "DeepSeek V3.2" },
             { value: "custom", label: "Custom", hint: "OpenAI-compatible endpoint" }
           ]
@@ -193301,7 +193358,7 @@ var init_init = __esm({
         ];
         if (llmProvider !== "none") {
           envLines.push("# LLM API key");
-          if (llmProvider === "openai" || llmProvider === "custom" || llmProvider === "atlascloud") {
+          if (llmProvider === "openai" || llmProvider === "custom" || llmProvider === "atlascloud" || llmProvider === "apiroute") {
             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");
@@ -193336,6 +193393,7 @@ var init_init = __esm({
         envLines.push("# ANTHROPIC_API_KEY=sk-ant-...");
         envLines.push("# OPENROUTER_API_KEY=sk-or-...");
         envLines.push("# REQUESTY_API_KEY=rqsty-...");
+        envLines.push("# API_ROUTE_API_KEY=sk-...");
         envLines.push("");
         mkdirSync3(targetDir, { recursive: true });
         writeFileSync3(targetPath, tomlContent, "utf-8");
@@ -195224,6 +195282,26 @@ function generateClaudeConfig() {
     }
   };
 }
+function generateQwenConfig() {
+  const cmd = `${resolveHookCommand()} hook --agent qwen`;
+  const hookEntry = {
+    type: "command",
+    command: cmd,
+    timeout: 10
+  };
+  return {
+    hooks: {
+      SessionStart: [{ hooks: [hookEntry] }],
+      SessionEnd: [{ hooks: [hookEntry] }],
+      PostToolUse: [{ hooks: [hookEntry] }],
+      PostToolUseFailure: [{ hooks: [hookEntry] }],
+      UserPromptSubmit: [{ hooks: [hookEntry] }],
+      PreCompact: [{ hooks: [hookEntry] }],
+      PostCompact: [{ hooks: [hookEntry] }],
+      Stop: [{ hooks: [hookEntry] }]
+    }
+  };
+}
 function generateGrokConfig() {
   const cmd = `${resolveHookCommand()} hook --agent grok`;
   const hookEntry = {
@@ -195254,7 +195332,13 @@ function isMemorixGrokCommand(value) {
 function isMemorixGrokHook(value) {
   return isJsonRecord(value) && value.type === "command" && isMemorixGrokCommand(value.command);
 }
-function mergeGrokHookConfig(existing, generated) {
+function isMemorixQwenCommand(value) {
+  return value === "memorix hook --agent qwen" || value === "memorix.cmd hook --agent qwen";
+}
+function isMemorixQwenHook(value) {
+  return isJsonRecord(value) && value.type === "command" && isMemorixQwenCommand(value.command);
+}
+function mergeCommandHookConfig(existing, generated, isOwnedHook) {
   const merged = { ...existing };
   const existingHooks = isJsonRecord(existing.hooks) ? { ...existing.hooks } : {};
   const generatedHooks = isJsonRecord(generated.hooks) ? generated.hooks : {};
@@ -195262,7 +195346,7 @@ function mergeGrokHookConfig(existing, generated) {
     const currentGroups = Array.isArray(existingHooks[event]) ? existingHooks[event] : [];
     const preservedGroups = currentGroups.flatMap((group) => {
       if (!isJsonRecord(group) || !Array.isArray(group.hooks)) return [group];
-      const preservedHooks = group.hooks.filter((hook) => !isMemorixGrokHook(hook));
+      const preservedHooks = group.hooks.filter((hook) => !isOwnedHook(hook));
       if (preservedHooks.length === 0) return [];
       return [{ ...group, hooks: preservedHooks }];
     });
@@ -195271,7 +195355,13 @@ function mergeGrokHookConfig(existing, generated) {
   merged.hooks = existingHooks;
   return merged;
 }
-function removeMemorixGrokHooks(config2) {
+function mergeGrokHookConfig(existing, generated) {
+  return mergeCommandHookConfig(existing, generated, isMemorixGrokHook);
+}
+function mergeQwenHookConfig(existing, generated) {
+  return mergeCommandHookConfig(existing, generated, isMemorixQwenHook);
+}
+function removeCommandHooks(config2, isOwnedHook) {
   const cleaned = { ...config2 };
   const hooks = isJsonRecord(config2.hooks) ? { ...config2.hooks } : null;
   if (!hooks) return cleaned;
@@ -195279,7 +195369,7 @@ function removeMemorixGrokHooks(config2) {
     if (!Array.isArray(groups)) continue;
     const preservedGroups = groups.flatMap((group) => {
       if (!isJsonRecord(group) || !Array.isArray(group.hooks)) return [group];
-      const preservedHooks = group.hooks.filter((hook) => !isMemorixGrokHook(hook));
+      const preservedHooks = group.hooks.filter((hook) => !isOwnedHook(hook));
       if (preservedHooks.length === 0) return [];
       return [{ ...group, hooks: preservedHooks }];
     });
@@ -195290,6 +195380,12 @@ function removeMemorixGrokHooks(config2) {
   else delete cleaned.hooks;
   return cleaned;
 }
+function removeMemorixGrokHooks(config2) {
+  return removeCommandHooks(config2, isMemorixGrokHook);
+}
+function removeMemorixQwenHooks(config2) {
+  return removeCommandHooks(config2, isMemorixQwenHook);
+}
 async function readGrokHookConfig(configPath) {
   let content;
   try {
@@ -195308,6 +195404,24 @@ async function readGrokHookConfig(configPath) {
     throw new Error(`Cannot safely update Grok hook config ${configPath}: ${reason}`);
   }
 }
+async function readQwenHookConfig(configPath) {
+  let content;
+  try {
+    content = await fs19.readFile(configPath, "utf-8");
+  } catch (error40) {
+    if (error40.code === "ENOENT") return {};
+    throw error40;
+  }
+  if (!content.trim()) return {};
+  try {
+    const parsed = JSON.parse(content);
+    if (!isJsonRecord(parsed)) throw new Error("top-level value must be an object");
+    return parsed;
+  } catch (error40) {
+    const reason = error40 instanceof Error ? error40.message : String(error40);
+    throw new Error(`Cannot safely update Qwen hook config ${configPath}: ${reason}`);
+  }
+}
 function generateCopilotConfig() {
   const cmd = `${resolveHookCommand()} hook`;
   const hasPwsh = detectPwsh();
@@ -195509,6 +195623,8 @@ function generateOpenCodePlugin() {
  */
 import { spawnSync } from 'node:child_process';
 
+const HOOK_TIMEOUT_MS = 30_000;
+
 export const MemorixPlugin = async ({ project, client, $, directory, worktree }) => {
   // Generate a stable session ID for this plugin lifetime
   const sessionId = \`opencode-\${Date.now().toString(36)}-\${Math.random().toString(36).slice(2, 8)}\`;
@@ -195534,14 +195650,14 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
    *  - spawnSync is simpler: no stream lifecycle, no writer.close() bugs
    *  - stdin pipe via input option is reliable cross-platform
    */
-  function runHook(payload) {
-    payload.session_id = sessionId;
+  function runHook(payload, activeSessionId = sessionId) {
+    payload.session_id = activeSessionId;
     const data = JSON.stringify(payload);
     const eventName = payload.hook_event_name || 'unknown';
     try {
       const result = spawnSync(hookCommand, ['hook'], {
         input: data,
-        timeout: 10_000,
+        timeout: HOOK_TIMEOUT_MS,
         encoding: 'utf-8',
         stdio: ['pipe', 'pipe', 'pipe'],
         shell: process.platform === 'win32',
@@ -195586,7 +195702,87 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
       .trim();
   }
 
+  function flushAssistantResponse(activeSessionId = sessionId) {
+    if (!pendingAssistantResponse?.text) return;
+    const deliveryKey = pendingAssistantResponse.id
+      ? \`\${pendingAssistantResponse.id}:\${pendingAssistantResponse.text}\`
+      : pendingAssistantResponse.text;
+    if (deliveryKey === lastDeliveredAssistantKey) return;
+    runHook({
+      agent: 'opencode',
+      hook_event_name: 'message.updated',
+      ai_response: pendingAssistantResponse.text,
+      message_id: pendingAssistantResponse.id,
+      cwd: directory,
+    }, activeSessionId);
+    lastDeliveredAssistantKey = deliveryKey;
+  }
+
+  function eventSessionId(event) {
+    const properties = event?.properties ?? {};
+    const value = properties.sessionID ?? properties.sessionId ?? properties.info?.id;
+    return typeof value === 'string' && value ? value : sessionId;
+  }
+
+  async function handleEvent({ event }) {
+    const properties = event?.properties ?? {};
+    const activeSessionId = eventSessionId(event);
+    switch (event?.type) {
+      case 'session.created':
+        runHook({
+          agent: 'opencode',
+          hook_event_name: 'session.created',
+          cwd: directory,
+        }, activeSessionId);
+        break;
+      case 'session.idle':
+        flushAssistantResponse(activeSessionId);
+        runHook({
+          agent: 'opencode',
+          hook_event_name: 'session.idle',
+          cwd: directory,
+        }, activeSessionId);
+        break;
+      case 'file.edited':
+        runHook({
+          agent: 'opencode',
+          hook_event_name: 'file.edited',
+          file_path: properties.file ?? properties.path ?? '',
+          cwd: directory,
+        }, activeSessionId);
+        break;
+      case 'command.executed':
+        runHook({
+          agent: 'opencode',
+          hook_event_name: 'command.executed',
+          command: properties.name ?? properties.command ?? '',
+          cwd: directory,
+        }, activeSessionId);
+        break;
+      case 'message.updated': {
+        const message = properties.info ?? properties.message ?? properties;
+        if (message?.role !== 'assistant') break;
+        const text = extractMessageText(message);
+        if (!text) break;
+        pendingAssistantResponse = { id: message.id, text };
+        break;
+      }
+      case 'session.compacted':
+        runHook({
+          agent: 'opencode',
+          hook_event_name: 'session.compacted',
+          cwd: directory,
+        }, activeSessionId);
+        break;
+      default:
+        break;
+    }
+  }
+
   return {
+    // OpenCode 1.x delivers lifecycle/file/command/message events through this
+    // generic hook. The named keys below remain for older compatible hosts.
+    event: handleEvent,
     /** Session created \u2014 record session start */
     'session.created': async ({ session }) => {
       runHook({
@@ -195598,21 +195794,7 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
 
     /** Session idle \u2014 record session end */
     'session.idle': async ({ session }) => {
-      if (pendingAssistantResponse?.text) {
-        const deliveryKey = pendingAssistantResponse.id
-          ? \`\${pendingAssistantResponse.id}:\${pendingAssistantResponse.text}\`
-          : pendingAssistantResponse.text;
-        if (deliveryKey !== lastDeliveredAssistantKey) {
-          runHook({
-            agent: 'opencode',
-            hook_event_name: 'message.updated',
-            ai_response: pendingAssistantResponse.text,
-            message_id: pendingAssistantResponse.id,
-            cwd: directory,
-          });
-          lastDeliveredAssistantKey = deliveryKey;
-        }
-      }
+      flushAssistantResponse();
       runHook({
         agent: 'opencode',
         hook_event_name: 'session.idle',
@@ -195720,7 +195902,7 @@ function v2RunHook(payload, directory, sessionId) {
   try {
     const result = spawnSync(v2HookCommand, ['hook'], {
       input: JSON.stringify(nextPayload),
-      timeout: 10_000,
+      timeout: HOOK_TIMEOUT_MS,
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe'],
       shell: process.platform === 'win32',
@@ -195844,7 +196026,7 @@ function setup(ctx) {
   return () => controller.abort();
 }
 
-export default { id: 'memorix', setup };
+export default { id: 'memorix', server: MemorixPlugin, setup };
 `;
 }
 async function installOpenCodeSkills(projectRoot, global2 = false) {
@@ -195854,6 +196036,8 @@ function getProjectConfigPath(agent, projectRoot) {
   switch (agent) {
     case "claude":
       return path31.join(projectRoot, ".claude", "settings.local.json");
+    case "qwen":
+      return path31.join(projectRoot, ".qwen", "settings.json");
     case "copilot":
       return path31.join(projectRoot, ".github", "hooks", "memorix.json");
     case "windsurf":
@@ -195895,6 +196079,8 @@ function getGlobalConfigPath(agent) {
   switch (agent) {
     case "claude":
       return path31.join(home, ".claude", "settings.json");
+    case "qwen":
+      return path31.join(home, ".qwen", "settings.json");
     case "copilot":
       return "";
     case "windsurf":
@@ -195936,6 +196122,8 @@ function getAgentRulesPath(agent, root, global2 = false) {
         return path31.join(root, ".cursor", "rules", "memorix.mdc");
       case "claude":
         return path31.join(root, ".claude", "CLAUDE.md");
+      case "qwen":
+        return path31.join(root, ".qwen", "QWEN.md");
       case "codex":
         return path31.join(root, ".codex", "AGENTS.md");
       case "kiro":
@@ -195964,6 +196152,8 @@ function getAgentRulesPath(agent, root, global2 = false) {
       return path31.join(root, ".cursor", "rules", "memorix.mdc");
     case "claude":
       return path31.join(root, "CLAUDE.md");
+    case "qwen":
+      return path31.join(root, "QWEN.md");
     case "copilot":
       return path31.join(root, ".github", "copilot-instructions.md");
     case "codex":
@@ -196040,6 +196230,12 @@ async function detectInstalledAgents() {
     agents.push("grok");
   } catch {
   }
+  const qwenDir = path31.join(home, ".qwen");
+  try {
+    await fs19.access(qwenDir);
+    agents.push("qwen");
+  } catch {
+  }
   const codexDir = path31.join(home, ".codex");
   try {
     await fs19.access(codexDir);
@@ -196123,10 +196319,10 @@ async function installHooks(agent, projectRoot, global2 = false) {
         const { access: access5, unlink: unlink3 } = await import("fs/promises");
         await access5(entry.path);
         const basename7 = path31.basename(entry.path);
-        if (basename7 === "AGENTS.md" || basename7 === "GEMINI.md" || basename7 === "CONTEXT.md") {
+        if (basename7 === "AGENTS.md" || basename7 === "GEMINI.md" || basename7 === "QWEN.md" || basename7 === "CONTEXT.md") {
           continue;
         }
-        if (agent === "grok" && path31.resolve(entry.path) === path31.resolve(configPath)) {
+        if ((agent === "grok" || agent === "qwen") && path31.resolve(entry.path) === path31.resolve(configPath)) {
           continue;
         }
         await unlink3(entry.path);
@@ -196141,6 +196337,9 @@ async function installHooks(agent, projectRoot, global2 = false) {
     case "claude":
       generated = generateClaudeConfig();
       break;
+    case "qwen":
+      generated = generateQwenConfig();
+      break;
     case "grok":
       generated = generateGrokConfig();
       break;
@@ -196247,6 +196446,15 @@ async function installHooks(agent, projectRoot, global2 = false) {
       await recordFile2(projectRoot, "hook", configPath, agent);
     } catch {
     }
+  } else if (agent === "qwen") {
+    const existing = await readQwenHookConfig(configPath);
+    const merged = mergeQwenHookConfig(existing, generated);
+    await fs19.writeFile(configPath, JSON.stringify(merged, null, 2), "utf-8");
+    try {
+      const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
+      await recordFile2(projectRoot, "hook", configPath, agent);
+    } catch {
+    }
   } else if (agent === "kiro") {
     const hookFiles = generateKiroHookFiles();
     const hooksDir = path31.join(path31.dirname(configPath));
@@ -196310,6 +196518,9 @@ async function installHooks(agent, projectRoot, global2 = false) {
     case "claude":
       events.push("session_start", "post_tool", "user_prompt", "pre_compact", "session_end");
       break;
+    case "qwen":
+      events.push("session_start", "session_end", "user_prompt", "post_tool", "pre_compact", "post_compact");
+      break;
     case "copilot":
       events.push("session_start", "session_end", "user_prompt", "post_tool");
       break;
@@ -196351,7 +196562,7 @@ async function installAgentRules(agent, projectRoot, global2 = false) {
   const rulesPath = getAgentRulesPath(agent, rulesRoot, global2);
   try {
     await fs19.mkdir(path31.dirname(rulesPath), { recursive: true });
-    if (agent === "claude" || agent === "codex" || agent === "opencode" || agent === "antigravity" || agent === "gemini-cli" || agent === "dsh" || agent === "grok") {
+    if (agent === "claude" || agent === "qwen" || agent === "codex" || agent === "opencode" || agent === "antigravity" || agent === "gemini-cli" || agent === "dsh" || agent === "grok") {
       try {
         const existing = await fs19.readFile(rulesPath, "utf-8");
         await fs19.writeFile(rulesPath, mergeMemorixRulesContent(existing, rulesContent), "utf-8");
@@ -196529,6 +196740,15 @@ async function uninstallHooks(agent, projectRoot, global2 = false) {
         await fs19.writeFile(configPath, JSON.stringify(cleaned, null, 2), "utf-8");
       }
       success2 = true;
+    } else if (agent === "qwen") {
+      const config2 = await readQwenHookConfig(configPath);
+      const cleaned = removeMemorixQwenHooks(config2);
+      if (Object.keys(cleaned).length === 0) {
+        await fs19.unlink(configPath);
+      } else {
+        await fs19.writeFile(configPath, JSON.stringify(cleaned, null, 2), "utf-8");
+      }
+      success2 = true;
     } else if (agent === "kiro" || agent === "opencode") {
       await fs19.unlink(configPath);
       success2 = true;
@@ -196552,13 +196772,13 @@ async function uninstallHooks(agent, projectRoot, global2 = false) {
     const agentFiles = prevFiles.filter((e5) => e5.agent === agent);
     for (const entry of agentFiles) {
       try {
-        if (agent === "grok" && path31.resolve(entry.path) === path31.resolve(configPath)) {
+        if ((agent === "grok" || agent === "qwen") && path31.resolve(entry.path) === path31.resolve(configPath)) {
           await removeFile2(projectRoot, entry.path);
           auditCleaned = true;
           continue;
         }
         const basename7 = path31.basename(entry.path);
-        if (basename7 === "AGENTS.md" || basename7 === "GEMINI.md" || basename7 === "CONTEXT.md") {
+        if (basename7 === "AGENTS.md" || basename7 === "GEMINI.md" || basename7 === "QWEN.md" || basename7 === "CONTEXT.md") {
           try {
             const content = await fs19.readFile(entry.path, "utf-8");
             const memorixStart = content.indexOf("# Memorix");
@@ -196617,7 +196837,7 @@ async function uninstallHooks(agent, projectRoot, global2 = false) {
 }
 async function getHookStatus(projectRoot) {
   const results = [];
-  const agents = ["claude", "copilot", "windsurf", "cursor", "kiro", "codex", "antigravity", "gemini-cli", "opencode", "pi", "trae", "grok"];
+  const agents = ["claude", "qwen", "copilot", "windsurf", "cursor", "kiro", "codex", "antigravity", "gemini-cli", "opencode", "pi", "trae", "grok"];
   for (const agent of agents) {
     const projectPath = getProjectConfigPath(agent, projectRoot);
     const globalPath = getGlobalConfigPath(agent);
@@ -196670,7 +196890,7 @@ var init_installers = __esm({
     "use strict";
     init_esm_shims();
     init_official_skills();
-    OPENCODE_PLUGIN_VERSION = 8;
+    OPENCODE_PLUGIN_VERSION = 9;
     AGENT_SKILL_DIRS = {
       cursor: { project: path31.join(".cursor", "skills"), global: path31.join(".cursor", "skills") },
       windsurf: { project: path31.join(".windsurf", "skills"), global: path31.join(".windsurf", "skills") },
@@ -198379,6 +198599,7 @@ async function installSingleAgent(installHooks2, agent, targetRoot, global2) {
 function getAgentLabel(agent) {
   const labels = {
     claude: "Claude Code",
+    qwen: "Qwen Code",
     windsurf: "Windsurf",
     cursor: "Cursor",
     copilot: "GitHub Copilot",
@@ -198397,6 +198618,7 @@ function getAgentLabel(agent) {
 function getAgentHint(agent) {
   const hints = {
     claude: "settings + instructions",
+    qwen: "settings.json hooks + QWEN.md guidance",
     windsurf: "hooks + rules",
     cursor: "hooks + rules",
     copilot: "hooks + instructions",
@@ -201557,7 +201779,7 @@ async function getSessionContext(projectDir2, projectId, limit2 = 3, reader2) {
     lines.push("## Key Project Memories");
     lines.push("*Durable working context \u2014 explicit decisions, gotchas, and discoveries.*");
     for (const obs of l2Obs) {
-      const emoji3 = TYPE_EMOJI[obs.type] ?? "[PIN]";
+      const emoji3 = OBSERVATION_ICONS[obs.type] ?? "[PIN]";
       const fact = obs.facts?.[0] ? ` \u2014 ${redactCredentials(obs.facts[0])}` : "";
       lines.push(`${emoji3} ${redactCredentials(obs.title)}${fact}`);
     }
@@ -201605,11 +201827,12 @@ async function getActiveSession(projectDir2, projectId) {
   const sessions = await loadAliasActiveSessions(aliasSet);
   return sessions.sort((a4, b4) => new Date(b4.startedAt).getTime() - new Date(a4.startedAt).getTime())[0] ?? null;
 }
-var PRIORITY_TYPES, RESUME_TYPES, TYPE_EMOJI, TYPE_WEIGHTS, NOISE_PATTERNS, COMMAND_TRACE_PATTERNS, SYSTEM_SELF_PATTERNS, SESSION_RESUME_OBSERVATION_LIMIT, SESSION_CONTEXT_OBSERVATION_LIMIT, AUTO_RESUME_SUMMARY_LIMIT, AUTO_RESUME_TITLE_LIMIT;
+var PRIORITY_TYPES, RESUME_TYPES, TYPE_WEIGHTS, NOISE_PATTERNS, COMMAND_TRACE_PATTERNS, SYSTEM_SELF_PATTERNS, SESSION_RESUME_OBSERVATION_LIMIT, SESSION_CONTEXT_OBSERVATION_LIMIT, AUTO_RESUME_SUMMARY_LIMIT, AUTO_RESUME_TITLE_LIMIT;
 var init_session = __esm({
   "src/memory/session.ts"() {
     "use strict";
     init_esm_shims();
+    init_types2();
     init_admission();
     init_disclosure_policy();
     init_aliases();
@@ -201637,18 +201860,6 @@ var init_session = __esm({
       "what-changed",
       "reasoning"
     ]);
-    TYPE_EMOJI = {
-      "gotcha": "[DISCOVERY]",
-      "decision": "[WHY]",
-      "problem-solution": "[FIX]",
-      "trade-off": "[TRADEOFF]",
-      "discovery": "[DISCOVERY]",
-      "how-it-works": "[INFO]",
-      "what-changed": "[CHANGE]",
-      "why-it-exists": "[DECISION]",
-      "session-request": "[SESSION]",
-      "probe": "[PROBE]"
-    };
     TYPE_WEIGHTS = {
       "gotcha": 6,
       "decision": 5.5,
@@ -209197,7 +209408,7 @@ var init_tool_profile = __esm({
 function getMcpServerInfo() {
   return {
     name: "memorix",
-    version: true ? "1.9.9" : "1.0.1"
+    version: true ? "1.9.11" : "1.0.1"
   };
 }
 function createMcpDiscoverResult(capabilities, serverInfo) {
@@ -211650,6 +211861,9 @@ var init_protocol = __esm({
           this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
             const handleTaskResult = async () => {
               const taskId = request.params.taskId;
+              if (!await this._taskStore.getTask(taskId, extra.sessionId)) {
+                throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+              }
               if (this._taskMessageQueue) {
                 let queuedMessage;
                 while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
@@ -211680,12 +211894,12 @@ var init_protocol = __esm({
                 throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
               }
               if (!isTerminal(task.status)) {
-                await this._waitForTaskUpdate(taskId, extra.signal);
+                await this._waitForTaskUpdate(taskId, extra.signal, extra.sessionId);
                 return await handleTaskResult();
               }
               if (isTerminal(task.status)) {
                 const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
-                this._clearTaskQueue(taskId);
+                this._clearTaskQueue(taskId, extra.sessionId);
                 return {
                   ...result,
                   _meta: {
@@ -211722,7 +211936,7 @@ var init_protocol = __esm({
                 throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
               }
               await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-              this._clearTaskQueue(request.params.taskId);
+              this._clearTaskQueue(request.params.taskId, extra.sessionId);
               const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
               if (!cancelledTask) {
                 throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
@@ -211850,6 +212064,19 @@ var init_protocol = __esm({
         const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
         const capturedTransport = this._transport;
         const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+        const sessionId = capturedTransport?.sessionId;
+        const store2 = this._taskStore;
+        let relatedTaskFound = true;
+        let relatedTaskLookup;
+        if (relatedTaskId && store2 && this._taskMessageQueue && sessionId !== void 0) {
+          relatedTaskFound = false;
+          relatedTaskLookup = (async () => {
+            if (!await store2.getTask(relatedTaskId, sessionId)) {
+              throw new McpError(ErrorCode.InvalidParams, `Task not found: ${relatedTaskId}`);
+            }
+            relatedTaskFound = true;
+          })();
+        }
         if (handler === void 0) {
           const errorResponse = {
             jsonrpc: "2.0",
@@ -211859,7 +212086,10 @@ var init_protocol = __esm({
               message: "Method not found"
             }
           };
-          if (relatedTaskId && this._taskMessageQueue) {
+          if (relatedTaskId && relatedTaskLookup) {
+            const queuedError = { type: "error", message: errorResponse, timestamp: Date.now() };
+            relatedTaskLookup.then(() => this._enqueueTaskMessage(relatedTaskId, queuedError, sessionId), () => capturedTransport?.send(errorResponse)).catch((error40) => this._onerror(new Error(`Failed to send an error response: ${error40}`)));
+          } else if (relatedTaskId && this._taskMessageQueue) {
             this._enqueueTaskMessage(relatedTaskId, {
               type: "error",
               message: errorResponse,
@@ -211910,7 +212140,10 @@ var init_protocol = __esm({
           closeSSEStream: extra?.closeSSEStream,
           closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
         };
-        Promise.resolve().then(() => {
+        (relatedTaskLookup ?? Promise.resolve()).then(() => {
+          if (relatedTaskLookup && abortController.signal.aborted) {
+            throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
+          }
           if (taskCreationParams) {
             this.assertTaskHandlerCapability(request.method);
           }
@@ -211945,7 +212178,7 @@ var init_protocol = __esm({
               ...error40["data"] !== void 0 && { data: error40["data"] }
             }
           };
-          if (relatedTaskId && this._taskMessageQueue) {
+          if (relatedTaskId && this._taskMessageQueue && relatedTaskFound) {
             await this._enqueueTaskMessage(relatedTaskId, {
               type: "error",
               message: errorResponse,
@@ -212425,7 +212658,7 @@ var init_protocol = __esm({
           throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
         }
         const maxQueueSize = this._options?.maxTaskQueueSize;
-        await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+        await this._taskMessageQueue.enqueue(taskId, message, sessionId ?? this._transport?.sessionId, maxQueueSize);
       }
       /**
        * Clears the message queue for a task and rejects any pending request resolvers.
@@ -212454,12 +212687,13 @@ var init_protocol = __esm({
        * Uses polling to check for updates at the task's configured poll interval.
        * @param taskId The task ID to wait for
        * @param signal Abort signal to cancel the wait
+       * @param sessionId Session of the request that waits, passed to the task store
        * @returns Promise that resolves when an update occurs or rejects if aborted
        */
-      async _waitForTaskUpdate(taskId, signal) {
+      async _waitForTaskUpdate(taskId, signal, sessionId) {
         let interval = this._options?.defaultTaskPollInterval ?? 1e3;
         try {
-          const task = await this._taskStore?.getTask(taskId);
+          const task = await this._taskStore?.getTask(taskId, sessionId);
           if (task?.pollInterval) {
             interval = task.pollInterval;
           }
@@ -215644,9 +215878,28 @@ var require_utils = __commonJS({
     init_esm_shims();
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isPort = RegExp.prototype.test.bind(/^\d*$/u);
     var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
     var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+    var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+    var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+    var BYTE_HEX = new Array(256);
+    {
+      const HEX_DIGITS = "0123456789ABCDEF";
+      for (let i4 = 0; i4 < 256; i4++) {
+        BYTE_HEX[i4] = "%" + HEX_DIGITS[i4 >> 4] + HEX_DIGITS[i4 & 15];
+      }
+    }
+    function percentEncodeNonAscii(cp) {
+      if (cp < 2048) {
+        return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+      }
+      if (cp < 65536) {
+        return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+      }
+      return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+    }
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -215671,91 +215924,105 @@ var require_utils = __commonJS({
       }
       return acc;
     }
+    var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+    var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+    var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
     var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-    function consumeIsZone(buffer) {
-      buffer.length = 0;
-      return true;
-    }
-    function consumeHextets(buffer, address, output) {
-      if (buffer.length) {
-        const hex = stringArrayToHexStripped(buffer);
-        if (hex !== "") {
-          address.push(hex);
-        } else {
-          output.error = true;
-          return false;
+    function isZoneIdentifier(zone) {
+      if (zone.length === 0) return false;
+      for (let i4 = 0; i4 < zone.length; i4++) {
+        if (isZoneCharacter(zone[i4])) continue;
+        if (zone[i4] === "%" && i4 + 2 < zone.length && isHexPair(zone.slice(i4 + 1, i4 + 3))) {
+          i4 += 2;
+          continue;
         }
-        buffer.length = 0;
+        return false;
       }
       return true;
     }
-    function getIPV6(input) {
-      let tokenCount = 0;
-      const output = { error: false, address: "", zone: "" };
-      const address = [];
-      const buffer = [];
-      let endipv6Encountered = false;
-      let endIpv6 = false;
-      let consume = consumeHextets;
-      for (let i4 = 0; i4 < input.length; i4++) {
-        const cursor = input[i4];
-        if (cursor === "[" || cursor === "]") {
-          continue;
-        }
-        if (cursor === ":") {
-          if (endipv6Encountered === true) {
-            endIpv6 = true;
+    function compressIPv6ZeroRun(hextets) {
+      let bestStart = -1;
+      let bestLength = 0;
+      let runStart = -1;
+      let runLength = 0;
+      for (let i4 = 0; i4 < hextets.length; i4++) {
+        if (hextets[i4] === "0") {
+          if (runStart === -1) runStart = i4;
+          runLength++;
+          if (runLength > bestLength) {
+            bestLength = runLength;
+            bestStart = runStart;
           }
-          if (!consume(buffer, address, output)) {
-            break;
-          }
-          if (++tokenCount > 7) {
-            output.error = true;
-            break;
-          }
-          if (i4 > 0 && input[i4 - 1] === ":") {
-            endipv6Encountered = true;
-          }
-          address.push(":");
-          continue;
-        } else if (cursor === "%") {
-          if (!consume(buffer, address, output)) {
-            break;
-          }
-          consume = consumeIsZone;
         } else {
-          buffer.push(cursor);
+          runStart = -1;
+          runLength = 0;
+        }
+      }
+      if (bestLength < 2) return hextets.join(":");
+      const head = hextets.slice(0, bestStart).join(":");
+      const tail = hextets.slice(bestStart + bestLength).join(":");
+      return head + "::" + tail;
+    }
+    function normalizeIPv6Address(input) {
+      const compression = input.indexOf("::");
+      if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
+      const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+      const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+      if (compression !== -1) {
+        if (left.length === 1 && left[0] === "") left.length = 0;
+        if (right.length === 1 && right[0] === "") right.length = 0;
+      }
+      const parts = left.concat(right);
+      let hextetCount = 0;
+      for (let i4 = 0; i4 < parts.length; i4++) {
+        const part = parts[i4];
+        if (part === "") return void 0;
+        if (part.indexOf(".") !== -1) {
+          if (i4 !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
+          hextetCount += 2;
           continue;
         }
+        if (!isHextet(part)) return void 0;
+        parts[i4] = parseInt(part, 16).toString(16);
+        hextetCount++;
       }
-      if (buffer.length) {
-        if (consume === consumeIsZone) {
-          output.zone = buffer.join("");
-        } else if (endIpv6) {
-          address.push(buffer.join(""));
-        } else {
-          address.push(stringArrayToHexStripped(buffer));
-        }
+      if (compression === -1) {
+        if (hextetCount !== 8) return void 0;
+        return compressIPv6ZeroRun(parts);
       }
-      output.address = address.join("");
-      return output;
+      if (hextetCount >= 8) return void 0;
+      const expanded = parts.slice(0, left.length);
+      for (let i4 = hextetCount; i4 < 8; i4++) expanded.push("0");
+      for (let i4 = left.length; i4 < parts.length; i4++) expanded.push(parts[i4]);
+      return compressIPv6ZeroRun(expanded);
     }
     function normalizeIPv6(host) {
-      if (findToken(host, ":") < 2) {
-        return { host, isIPV6: false };
-      }
-      const ipv63 = getIPV6(host);
-      if (!ipv63.error) {
-        let newHost = ipv63.address;
-        let escapedHost = ipv63.address;
-        if (ipv63.zone) {
-          newHost += "%" + ipv63.zone;
-          escapedHost += "%25" + ipv63.zone;
-        }
-        return { host: newHost, isIPV6: true, escapedHost };
-      } else {
-        return { host, isIPV6: false };
-      }
+      const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+      const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+      if (hasBracket && !bracketed) return { host, isIPV6: false, error: true };
+      let input = bracketed ? host.slice(1, -1) : host;
+      if (bracketed && isIPvFuture(input)) {
+        input = input.toLowerCase();
+        return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+      }
+      if (findToken(input, ":") < 2) {
+        return { host, isIPV6: false, error: bracketed };
+      }
+      let zoneIdentifier = "";
+      const zoneSeparator = input.indexOf("%");
+      if (zoneSeparator !== -1) {
+        const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+        zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+        if (!isZoneIdentifier(zoneIdentifier)) return { host, isIPV6: false, error: true };
+        input = input.slice(0, zoneSeparator);
+      }
+      const address = normalizeIPv6Address(input);
+      if (address === void 0) return { host, isIPV6: false, error: true };
+      return {
+        host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+        escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+        isIPV6: true
+      };
     }
     function findToken(str2, token) {
       let ind = 0;
@@ -215874,7 +216141,8 @@ var require_utils = __commonJS({
     function normalizePathEncoding(input) {
       let output = "";
       for (let i4 = 0; i4 < input.length; i4++) {
-        if (input[i4] === "%" && i4 + 2 < input.length) {
+        const ch2 = input[i4];
+        if (ch2 === "%" && i4 + 2 < input.length) {
           const hex = input.slice(i4 + 1, i4 + 3);
           if (isHexPair(hex)) {
             const normalizedHex = hex.toUpperCase();
@@ -215888,10 +216156,152 @@ var require_utils = __commonJS({
             continue;
           }
         }
-        if (isPathCharacter(input[i4])) {
-          output += input[i4];
+        if (isPathCharacter(ch2)) {
+          output += ch2;
+        } else {
+          const code = input.charCodeAt(i4);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch2 : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i4 + 1 < input.length) {
+            const low = input.charCodeAt(i4 + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i4++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function serializePathEncoding(input, pathNoScheme = false) {
+      let output = "";
+      let firstSegment = pathNoScheme && input[0] !== "/";
+      for (let i4 = 0; i4 < input.length; i4++) {
+        const ch2 = input[i4];
+        if (ch2 === "%" && i4 + 2 < input.length) {
+          const hex = input.slice(i4 + 1, i4 + 3);
+          if (isHexPair(hex)) {
+            output += "%" + hex.toUpperCase();
+            i4 += 2;
+            continue;
+          }
+        }
+        if (ch2 === "/") {
+          firstSegment = false;
+        }
+        if (isPathCharacter(ch2) && (ch2 !== ":" || !firstSegment)) {
+          output += ch2;
+        } else {
+          const code = input.charCodeAt(i4);
+          if (code < 128) {
+            output += BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i4 + 1 < input.length) {
+            const low = input.charCodeAt(i4 + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i4++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function encodeComponent(input, isAllowed) {
+      let output = "";
+      for (let i4 = 0; i4 < input.length; i4++) {
+        const ch2 = input[i4];
+        if (ch2 === "%" && i4 + 2 < input.length) {
+          const hex = input.slice(i4 + 1, i4 + 3);
+          if (isHexPair(hex)) {
+            output += "%" + hex.toUpperCase();
+            i4 += 2;
+            continue;
+          }
+        }
+        if (isAllowed(ch2)) {
+          output += ch2;
+        } else {
+          const code = input.charCodeAt(i4);
+          if (code < 128) {
+            output += BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i4 + 1 < input.length) {
+            const low = input.charCodeAt(i4 + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i4++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function encodeUserinfo(input) {
+      return encodeComponent(input, isUserinfoCharacter);
+    }
+    function encodeQuery(input) {
+      return encodeComponent(input, isQueryFragmentCharacter);
+    }
+    function encodeFragment(input) {
+      return encodeComponent(input, isQueryFragmentCharacter);
+    }
+    function isEscapeSafe(cp) {
+      return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+    }
+    function normalizeQueryFragmentEncoding(input) {
+      let output = "";
+      for (let i4 = 0; i4 < input.length; i4++) {
+        const ch2 = input[i4];
+        if (ch2 === "%" && i4 + 2 < input.length) {
+          const hex = input.slice(i4 + 1, i4 + 3);
+          if (isHexPair(hex)) {
+            const normalizedHex = hex.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i4 += 2;
+            continue;
+          }
+        }
+        if (isQueryFragmentCharacter(ch2)) {
+          output += ch2;
         } else {
-          output += escape(input[i4]);
+          const code = input.charCodeAt(i4);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch2 : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i4 + 1 < input.length) {
+            const low = input.charCodeAt(i4 + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i4++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
         }
       }
       return output;
@@ -215914,14 +216324,18 @@ var require_utils = __commonJS({
     function recomposeAuthority(component) {
       const uriTokens = [];
       if (component.userinfo !== void 0) {
-        uriTokens.push(component.userinfo);
+        uriTokens.push(encodeUserinfo(component.userinfo));
         uriTokens.push("@");
       }
       if (component.host !== void 0) {
-        let host = unescape(component.host);
+        let host = component.host;
         if (!isIPv4(host)) {
-          const ipV6res = normalizeIPv6(host);
-          if (ipV6res.isIPV6 === true) {
+          let ipV6res = normalizeIPv6(host);
+          if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+            host = normalizePercentEncoding(host, true);
+            ipV6res = normalizeIPv6(host);
+          }
+          if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
             host = reescapeHostDelimiters(host, false);
@@ -215930,8 +216344,12 @@ var require_utils = __commonJS({
         uriTokens.push(host);
       }
       if (typeof component.port === "number" || typeof component.port === "string") {
+        const port = String(component.port);
+        if (!isPort(port)) {
+          throw new TypeError("URI port is malformed.");
+        }
         uriTokens.push(":");
-        uriTokens.push(String(component.port));
+        uriTokens.push(port);
       }
       return uriTokens.length ? uriTokens.join("") : void 0;
     }
@@ -215941,6 +216359,11 @@ var require_utils = __commonJS({
       reescapeHostDelimiters,
       normalizePercentEncoding,
       normalizePathEncoding,
+      serializePathEncoding,
+      normalizeQueryFragmentEncoding,
+      encodeUserinfo,
+      encodeQuery,
+      encodeFragment,
       escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
@@ -215957,7 +216380,7 @@ var require_schemes = __commonJS({
     "use strict";
     init_esm_shims();
     var { isUUID } = require_utils();
-    var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+    var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
     var supportedSchemeNames = (
       /** @type {const} */
       [
@@ -216018,9 +216441,10 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path50, query] = wsComponent.resourceName.split("?");
+        const queryIndex = wsComponent.resourceName.indexOf("?");
+        const path50 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
         wsComponent.path = path50 && path50 !== "/" ? path50 : void 0;
-        wsComponent.query = query;
+        wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
         wsComponent.resourceName = void 0;
       }
       wsComponent.fragment = void 0;
@@ -216032,7 +216456,7 @@ var require_schemes = __commonJS({
         return urnComponent;
       }
       const matches = urnComponent.path.match(URN_REG);
-      if (matches) {
+      if (matches && matches[0] === urnComponent.path) {
         const scheme = options.scheme || urnComponent.scheme || "urn";
         urnComponent.nid = matches[1].toLowerCase();
         urnComponent.nss = matches[2];
@@ -216167,8 +216591,17 @@ var require_fast_uri = __commonJS({
   "node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
+    var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+    var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+    function decodeValidScheme(scheme) {
+      const decodedScheme = unescape(String(scheme));
+      if (!VALID_SCHEME.test(decodedScheme)) {
+        throw new TypeError(MALFORMED_SCHEME_ERROR);
+      }
+      return decodedScheme;
+    }
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
@@ -216181,12 +216614,34 @@ var require_fast_uri = __commonJS({
     }
     function resolve9(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
-      const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
-      if (baseMalformed || relativeMalformed) {
+      const {
+        parsed: baseParsed,
+        malformedAuthorityOrPort: baseMalformed,
+        malformedPercentEncoding: baseMalformedPercentEncoding,
+        malformedSchemeSpecific: baseMalformedSchemeSpecific,
+        malformedHost: baseMalformedHost,
+        malformedScheme: baseMalformedScheme
+      } = parseWithStatus(baseURI, schemelessOptions);
+      const {
+        parsed: relativeParsed,
+        malformedAuthorityOrPort: relativeMalformed,
+        malformedPercentEncoding: relativeMalformedPercentEncoding,
+        malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+        malformedHost: relativeMalformedHost,
+        malformedScheme: relativeMalformedScheme
+      } = parseWithStatus(relativeURI, schemelessOptions);
+      if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
         throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
       }
       const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+      const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+      const resolvedHost = resolved.host;
+      const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+      canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+      const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !new RegExp("\\P{ASCII}", "u").test(resolvedHost);
+      if (resolved.error && !encodedASCIIHost) {
+        throw new Error(resolved.error);
+      }
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
@@ -216246,7 +216701,7 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       const normalizedA = normalizeComparableURI(uriA, options);
       const normalizedB = normalizeComparableURI(uriB, options);
-      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -216267,19 +216722,22 @@ var require_fast_uri = __commonJS({
       };
       const options = Object.assign({}, opts);
       const uriTokens = [];
+      if (component.scheme) {
+        component.scheme = decodeValidScheme(component.scheme);
+      }
       const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+      const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
+      const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escapePreservingEscapes(component.path);
-          if (component.scheme !== void 0) {
-            component.path = component.path.split("%3A").join(":");
-          }
+          component.path = serializePathEncoding(component.path, pathNoScheme);
         } else {
           component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
+        component.scheme = decodeValidScheme(component.scheme);
         uriTokens.push(component.scheme, ":");
       }
       const authority = recomposeAuthority(component);
@@ -216297,16 +216755,19 @@ var require_fast_uri = __commonJS({
         if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
           s4 = removeDotSegments(s4);
         }
+        if (pathNoScheme) {
+          s4 = serializePathEncoding(s4, true);
+        }
         if (authority === void 0 && s4[0] === "/" && s4[1] === "/") {
           s4 = "/%2F" + s4.slice(2);
         }
         uriTokens.push(s4);
       }
       if (component.query !== void 0) {
-        uriTokens.push("?", component.query);
+        uriTokens.push("?", encodeQuery(component.query));
       }
       if (component.fragment !== void 0) {
-        uriTokens.push("#", component.fragment);
+        uriTokens.push("#", encodeFragment(component.fragment));
       }
       return uriTokens.join("");
     }
@@ -216322,6 +216783,35 @@ var require_fast_uri = __commonJS({
       }
       return void 0;
     }
+    function hasMalformedPercentEncoding(component) {
+      if (component === void 0) return false;
+      let percent = component.indexOf("%");
+      while (percent !== -1) {
+        if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+          return true;
+        }
+        percent = component.indexOf("%", percent + 3);
+      }
+      return false;
+    }
+    function isIPLiteral(host) {
+      return host[0] === "[" && host[host.length - 1] === "]";
+    }
+    function hasMalformedComponentPercentEncoding(matches) {
+      const host = matches[4];
+      return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+    }
+    function canonicalizeHost(parsed, options, schemeHandler, isIP5) {
+      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP5 === false && nonSimpleDomain(parsed.host)) {
+        try {
+          parsed.host = new URL("http://" + parsed.host).hostname;
+        } catch (e5) {
+          parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e5;
+          return true;
+        }
+      }
+      return false;
+    }
     function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
@@ -216334,6 +216824,11 @@ var require_fast_uri = __commonJS({
         fragment: void 0
       };
       let malformedAuthorityOrPort = false;
+      let malformedPercentEncoding = false;
+      let malformedSchemeSpecific = false;
+      let malformedHost = false;
+      let malformedIPLiteral = false;
+      let malformedScheme = false;
       let isIP5 = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -216370,6 +216865,19 @@ var require_fast_uri = __commonJS({
         parsed.path = matches[6] || "";
         parsed.query = matches[7];
         parsed.fragment = matches[8];
+        if (parsed.scheme !== void 0) {
+          const decodedScheme = unescape(parsed.scheme);
+          if (VALID_SCHEME.test(decodedScheme)) {
+            parsed.scheme = decodedScheme.toLowerCase();
+          } else {
+            parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+            malformedScheme = true;
+          }
+        }
+        malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+        if (malformedPercentEncoding) {
+          parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+        }
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
@@ -216381,9 +216889,16 @@ var require_fast_uri = __commonJS({
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
+            const bracketedIPLiteral = isIPLiteral(parsed.host);
+            const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
             const ipv6result = normalizeIPv6(parsed.host);
-            parsed.host = ipv6result.host.toLowerCase();
-            isIP5 = ipv6result.isIPV6;
+            isIP5 = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+            malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+            parsed.host = isIP5 ? ipv6result.host : ipv6result.host.toLowerCase();
+            if (malformedIPLiteral) {
+              parsed.error = parsed.error || "URI host is malformed.";
+              malformedAuthorityOrPort = true;
+            }
           } else {
             isIP5 = true;
           }
@@ -216401,42 +216916,37 @@ var require_fast_uri = __commonJS({
           parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
         }
         const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-          if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP5 === false && nonSimpleDomain(parsed.host)) {
-            try {
-              parsed.host = new URL("http://" + parsed.host).hostname;
-            } catch (e5) {
-              parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e5;
-            }
+        if (!malformedIPLiteral) {
+          malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP5);
+        }
+        if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+          let host = isIP5 ? parsed.host : normalizePercentEncoding(parsed.host, true);
+          if (!isIP5) {
+            host = normalizePercentEncoding(host.toLowerCase());
           }
+          parsed.host = reescapeHostDelimiters(host, isIP5);
         }
         if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-          if (uri.indexOf("%") !== -1) {
-            if (parsed.scheme !== void 0) {
-              parsed.scheme = unescape(parsed.scheme);
-            }
-            if (parsed.host !== void 0) {
-              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP5);
-            }
-          }
           if (parsed.path) {
             parsed.path = normalizePathEncoding(parsed.path);
           }
+          if (parsed.query) {
+            parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+          }
           if (parsed.fragment) {
-            try {
-              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-            } catch {
-              parsed.error = parsed.error || "URI malformed";
-            }
+            parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
           }
         }
         if (schemeHandler && schemeHandler.parse) {
           schemeHandler.parse(parsed, options);
+          if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) {
+            malformedSchemeSpecific = true;
+          }
         }
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return { parsed, malformedAuthorityOrPort };
+      return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
     }
     function parse5(uri, opts) {
       return parseWithStatus(uri, opts).parsed;
@@ -216445,20 +216955,28 @@ var require_fast_uri = __commonJS({
       return normalizeStringWithStatus(uri, opts).normalized;
     }
     function normalizeStringWithStatus(uri, opts) {
-      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
       return {
-        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-        malformedAuthorityOrPort
+        normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort,
+        malformedPercentEncoding,
+        malformedSchemeSpecific,
+        malformedHost,
+        malformedScheme
       };
     }
     function normalizeComparableURI(uri, opts) {
-      if (typeof uri === "string") {
-        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-        return malformedAuthorityOrPort ? void 0 : normalized;
+      if (typeof uri !== "string" && typeof uri !== "object") {
+        return void 0;
       }
-      if (typeof uri === "object") {
-        return serialize(uri, opts);
+      let value;
+      try {
+        value = typeof uri === "string" ? uri : serialize(uri, opts);
+      } catch {
+        return void 0;
       }
+      const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+      return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
     }
     var fastUri = {
       SCHEMES,
@@ -221070,6 +221588,42 @@ var init_mcp_server = __esm({
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
+function toolInputElementCount(value, max) {
+  let count3 = 0;
+  const stack = [value];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === null || typeof node !== "object")
+      continue;
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        if (++count3 > max)
+          return count3;
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    } else {
+      for (const key in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, key))
+          continue;
+        if (++count3 > max)
+          return count3;
+        const child = node[key];
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    }
+  }
+  return count3;
+}
+function resolveMaxToolInputElements(value) {
+  if (value === void 0 || value === Infinity)
+    return void 0;
+  if (typeof value !== "number" || Number.isNaN(value) || value < 1) {
+    throw new RangeError(`maxToolInputElements must be a number of at least 1, or Infinity, got ${String(value)}`);
+  }
+  return value;
+}
 function isZodTypeLike(value) {
   return value !== null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
 }
@@ -221160,6 +221714,7 @@ var init_mcp = __esm({
         this._resourceHandlersInitialized = false;
         this._promptHandlersInitialized = false;
         this.server = new Server(serverInfo, options);
+        this._maxToolInputElements = resolveMaxToolInputElements(options?.maxToolInputElements);
       }
       /**
        * Access experimental features.
@@ -221290,12 +221845,15 @@ var init_mcp = __esm({
        * Validates tool input arguments against the tool's input schema.
        */
       async validateToolInput(tool, args, toolName) {
+        if (this._maxToolInputElements !== void 0 && toolInputElementCount(args, this._maxToolInputElements) > this._maxToolInputElements) {
+          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${toolName}: arguments contain more than the maximum of ${this._maxToolInputElements} elements`);
+        }
         if (!tool.inputSchema) {
           return void 0;
         }
         const inputObj = normalizeObjectSchema(tool.inputSchema);
         const schemaToParse = inputObj ?? tool.inputSchema;
-        const parseResult = await safeParseAsync3(schemaToParse, args);
+        const parseResult = await safeParseAsync3(schemaToParse, args ?? {});
         if (!parseResult.success) {
           const error40 = "error" in parseResult ? parseResult.error : "Unknown error";
           const errorMessage = getParseErrorMessage(error40);
@@ -221533,7 +222091,7 @@ var init_mcp = __esm({
           }
           if (prompt2.argsSchema) {
             const argsObj = normalizeObjectSchema(prompt2.argsSchema);
-            const parseResult = await safeParseAsync3(argsObj, request.params.arguments);
+            const parseResult = await safeParseAsync3(argsObj, request.params.arguments ?? {});
             if (!parseResult.success) {
               const error40 = "error" in parseResult ? parseResult.error : "Unknown error";
               const errorMessage = getParseErrorMessage(error40);
@@ -225130,7 +225688,8 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           "OPENAI_API_KEY",
           "ANTHROPIC_API_KEY",
           ...resolved.memory.llm.provider === "openrouter" || resolved.memory.llm.baseUrl?.includes("openrouter.ai") ? ["OPENROUTER_API_KEY"] : [],
-          ...resolved.memory.llm.provider === "requesty" ? ["REQUESTY_API_KEY"] : []
+          ...resolved.memory.llm.provider === "requesty" ? ["REQUESTY_API_KEY"] : [],
+          ...resolved.memory.llm.provider === "apiroute" ? ["API_ROUTE_API_KEY"] : []
         ];
         if (llmKey) {
           const src2 = resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource });
@@ -265461,12 +266020,13 @@ __export(image_loader_exports, {
   analyzeImage: () => analyzeImage
 });
 async function callVisionLLM(systemPrompt, imageBase64, mimeType) {
-  const apiKey = getLLMApiKey();
+  const config2 = getLLMConfig();
+  const apiKey = config2?.apiKey ?? getLLMApiKey();
   if (!apiKey) {
     throw new Error("No LLM API key configured for image analysis.");
   }
-  const baseUrl = normalizeOpenAICompatibleBaseUrl(getLLMBaseUrl("https://api.openai.com/v1"));
-  const model = getLLMModel("gpt-4o");
+  const baseUrl = normalizeOpenAICompatibleBaseUrl(config2?.baseUrl ?? getLLMBaseUrl("https://api.openai.com/v1"));
+  const model = config2?.model ?? getLLMModel("gpt-4o");
   const response = await fetch(`${baseUrl}/chat/completions`, {
     method: "POST",
     headers: {
@@ -265521,7 +266081,7 @@ async function analyzeImage(input) {
   const config2 = getLLMConfig();
   if (!OPENAI_COMPATIBLE_PROVIDERS.has(config2.provider)) {
     throw new Error(
-      `Image analysis requires an OpenAI-compatible provider (openai, openrouter, requesty, or custom). Current provider "${config2.provider}" uses a different API shape. Set MEMORIX_LLM_PROVIDER=openai or configure an OpenAI-compatible base URL.`
+      `Image analysis requires an OpenAI-compatible provider (openai, openrouter, requesty, apiroute, or custom). Current provider "${config2.provider}" uses a different API shape. Set MEMORIX_LLM_PROVIDER=openai or configure an OpenAI-compatible base URL.`
     );
   }
   const bytes = decodeBase64ImagePayload(input.base64, MAX_VISION_IMAGE_BYTES);
@@ -265560,7 +266120,7 @@ var init_image_loader = __esm({
     init_provider2();
     init_secret_filter();
     init_image_payload();
-    OPENAI_COMPATIBLE_PROVIDERS = /* @__PURE__ */ new Set(["openai", "openrouter", "requesty", "custom"]);
+    OPENAI_COMPATIBLE_PROVIDERS = /* @__PURE__ */ new Set(["openai", "openrouter", "requesty", "apiroute", "custom"]);
     MAX_VISION_PROMPT_CHARS = 12e3;
     MAX_VISION_DESCRIPTION_CHARS = 12e3;
     MAX_VISION_LABELS = 50;
@@ -265842,8 +266402,8 @@ async function createMemorixServer(cwd, existingServer, sharedTeam, options = {}
   if (!lightweightUnresolvedSession && !deferProjectRuntimeInit) {
     try {
       const { getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-      const allObs = getAllObservations2();
-      const observedIds = [...new Set(allObs.map((o4) => o4.projectId))];
+      const store2 = getObservationStore();
+      const observedIds = store2.listProjectIds ? await store2.listProjectIds() : [...new Set(getAllObservations2().map((o4) => o4.projectId))];
       const merged = await autoMergeByBaseName(observedIds);
       if (merged > 0) {
         console.error(`[memorix] Auto-merged ${merged} alias group(s) by base name`);
@@ -265884,8 +266444,8 @@ async function createMemorixServer(cwd, existingServer, sharedTeam, options = {}
         try {
           const { getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
           await initObservations(projectDir2);
-          const allObs = getAllObservations2();
-          const observedIds = [...new Set(allObs.map((o4) => o4.projectId))];
+          const store2 = getObservationStore();
+          const observedIds = store2.listProjectIds ? await store2.listProjectIds() : [...new Set(getAllObservations2().map((o4) => o4.projectId))];
           const merged = await autoMergeByBaseName(observedIds);
           if (merged > 0) {
             console.error(`[memorix] Auto-merged ${merged} alias group(s) by base name`);
@@ -271256,20 +271816,15 @@ var init_websocket = __esm({
         if (typeof args[0] === "function") {
           const [createEvents, options] = args;
           return async function upgradeWebSocket2(c6, next) {
-            const events = await createEvents(c6);
-            const result = await handler(c6, events, options);
-            if (result) {
-              return result;
-            }
+            const result = await handler(c6, await createEvents(c6), options);
+            if (result) return result;
             await next();
           };
         } else {
           const [c6, events, options] = args;
           return (async () => {
             const upgraded = await handler(c6, events, options);
-            if (!upgraded) {
-              throw new Error("Failed to upgrade WebSocket");
-            }
+            if (!upgraded) throw new Error("Failed to upgrade WebSocket");
             return upgraded;
           })();
         }
@@ -272428,6 +272983,57 @@ var init_mediaType = __esm({
   }
 });
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/requestBody.js
+function requestBodyTooLargeMessage(maxBytes) {
+  return `Payload Too Large: Request body must not exceed ${maxBytes} bytes`;
+}
+function resolveMaxRequestBodySize(value) {
+  if (value === void 0) {
+    return DEFAULT_MAX_REQUEST_BODY_SIZE;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`maxRequestBodySize must be a positive number of bytes, got ${String(value)}`);
+  }
+  return value;
+}
+async function readRequestBody(request, maxBytes = DEFAULT_MAX_REQUEST_BODY_SIZE) {
+  if (Number(request.headers.get("content-length")) > maxBytes) {
+    return { tooLarge: true };
+  }
+  if (request.body === null) {
+    return { tooLarge: false, text: "" };
+  }
+  const reader2 = request.body.getReader();
+  const decoder2 = new TextDecoder();
+  let received = 0;
+  let text3 = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader2.read();
+      if (done) {
+        break;
+      }
+      received += value.byteLength;
+      if (received > maxBytes) {
+        return { tooLarge: true };
+      }
+      text3 += decoder2.decode(value, { stream: true });
+    }
+  } finally {
+    reader2.releaseLock();
+  }
+  return { tooLarge: false, text: text3 + decoder2.decode() };
+}
+var DEFAULT_MAX_REQUEST_BODY_SIZE, MAX_BATCH_SIZE2;
+var init_requestBody = __esm({
+  "node_modules/@modelcontextprotocol/sdk/dist/esm/server/requestBody.js"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_MAX_REQUEST_BODY_SIZE = 4 * 1024 * 1024;
+    MAX_BATCH_SIZE2 = 100;
+  }
+});
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/sseKeepAlive.js
 function armSseKeepAlive(intervalMs, onTick) {
   if (!Number.isFinite(intervalMs) || intervalMs < 1) {
@@ -272454,6 +273060,7 @@ var init_webStandardStreamableHttp = __esm({
     "use strict";
     init_esm_shims();
     init_mediaType();
+    init_requestBody();
     init_sseKeepAlive();
     init_types8();
     WebStandardStreamableHTTPServerTransport = class {
@@ -272478,6 +273085,7 @@ var init_webStandardStreamableHttp = __esm({
         this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
         this._retryInterval = options.retryInterval;
         this._keepAliveMs = options.keepAliveMs ?? DEFAULT_SSE_KEEP_ALIVE_MS;
+        this._maxRequestBodySize = resolveMaxRequestBodySize(options.maxRequestBodySize);
       }
       /**
        * Arms a keep-alive interval for an SSE stream that periodically writes an SSE
@@ -272839,12 +273447,22 @@ data:
             rawMessage = options.parsedBody;
           } else {
             try {
-              rawMessage = await req.json();
+              const body = await readRequestBody(req, this._maxRequestBodySize);
+              if (body.tooLarge) {
+                const message = requestBodyTooLargeMessage(this._maxRequestBodySize);
+                this.onerror?.(new Error(message));
+                return this.createJsonErrorResponse(413, -32e3, message);
+              }
+              rawMessage = JSON.parse(body.text);
             } catch {
               this.onerror?.(new Error("Parse error: Invalid JSON"));
               return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
             }
           }
+          if (Array.isArray(rawMessage) && rawMessage.length > MAX_BATCH_SIZE2) {
+            this.onerror?.(new Error(`Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE2} messages`));
+            return this.createJsonErrorResponse(400, -32600, `Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE2} messages`);
+          }
           let messages;
           try {
             if (Array.isArray(rawMessage)) {
@@ -278143,6 +278761,7 @@ function extractEventName(payload, agent) {
     case "cursor":
       return payload.hook_event_name ?? inferCursorEvent(payload);
     case "claude":
+    case "qwen":
       return payload.hook_event_name ?? "";
     case "codex":
       return payload.hook_event_name ?? "";
@@ -278191,7 +278810,7 @@ function normalizeClaude(payload, event) {
     if (/^bash$/i.test(toolName) && toolInput?.command) {
       result.command = toolInput.command;
     }
-    if (/^(write|edit|multi_edit|multiedittool)$/i.test(toolName)) {
+    if (/^(write|write_file|edit|edit_file|multi_edit|multiedittool)$/i.test(toolName)) {
       result.filePath = toolInput?.file_path ?? toolInput?.filePath;
     }
   }
@@ -278481,6 +279100,7 @@ function normalizeHookInput(payload) {
   let agentSpecific = {};
   switch (agent) {
     case "claude":
+    case "qwen":
       agentSpecific = normalizeClaude(payload, event);
       break;
     case "copilot":
@@ -278564,9 +279184,12 @@ var init_normalizer = __esm({
       PreToolUse: "post_tool",
       // we handle pre as post for memory purposes
       PostToolUse: "post_tool",
+      PostToolUseFailure: "post_tool",
       PreCompact: "pre_compact",
+      PostCompact: "post_compact",
       Stop: "session_end",
       SessionEnd: "session_end",
+      SessionDelete: "session_end",
       // Grok Build (Claude-compatible PascalCase plus snake_case hookEventName)
       user_prompt_submit: "user_prompt",
       pre_tool_use: "post_tool",
@@ -278847,11 +279470,7 @@ async function readHookStdin(stdin2, timeoutMs) {
       stdin2.removeListener("end", finish);
       stdin2.removeListener("error", finish);
       stdin2.pause?.();
-      if (!stdin2.isTTY) {
-        stdin2.destroy?.();
-      } else {
-        stdin2.unref?.();
-      }
+      stdin2.unref?.();
       resolve9(Buffer.concat(chunks).toString("utf-8").trim());
     };
     const onData = (chunk) => {
@@ -278932,7 +279551,7 @@ var init_lifecycle2 = __esm({
 // src/hooks/handler.ts
 var handler_exports = {};
 __export(handler_exports, {
-  TYPE_EMOJI: () => TYPE_EMOJI2,
+  TYPE_EMOJI: () => TYPE_EMOJI,
   formatHookOutput: () => formatHookOutput,
   handleHookEvent: () => handleHookEvent,
   resetCooldowns: () => resetCooldowns,
@@ -279496,7 +280115,7 @@ function toAntigravityHookOutput(rawEventName, output) {
       return {};
   }
 }
-var TYPE_EMOJI2, cooldowns, COOLDOWN_MS, MIN_PROMPT_LENGTH, MAX_CONTENT_LENGTH, STORAGE_POLICY;
+var TYPE_EMOJI, cooldowns, COOLDOWN_MS, MIN_PROMPT_LENGTH, MAX_CONTENT_LENGTH, STORAGE_POLICY;
 var init_handler = __esm({
   "src/hooks/handler.ts"() {
     "use strict";
@@ -279506,7 +280125,7 @@ var init_handler = __esm({
     init_pattern_detector();
     init_significance_filter();
     init_lifecycle2();
-    TYPE_EMOJI2 = {
+    TYPE_EMOJI = {
       "gotcha": "[GOTCHA]",
       "decision": "[DECISION]",
       "problem-solution": "[FIX]",
@@ -279600,7 +280219,8 @@ var init_types9 = __esm({
       pi: "community",
       omp: "community",
       antigravity: "community",
-      grok: "community"
+      grok: "community",
+      qwen: "extended"
     };
   }
 });
@@ -279650,6 +280270,7 @@ async function installSingleAgent2(agent, cwd, global2) {
 function getAgentLabel2(agent) {
   const labels = {
     claude: "Claude Code",
+    qwen: "Qwen Code",
     codex: "Codex",
     windsurf: "Windsurf",
     cursor: "Cursor",
@@ -279671,6 +280292,7 @@ function getAgentLabel2(agent) {
 function getAgentHint2(agent) {
   const hints = {
     claude: ".claude/settings.json",
+    qwen: ".qwen/settings.json",
     windsurf: ".windsurf/hooks.json",
     cursor: ".cursor/hooks.json",
     copilot: ".github/hooks/memorix.json (project-only, no global)",
@@ -289707,6 +290329,7 @@ function ConfigureView({ onBack }) {
     { key: "anthropic", label: "Anthropic", hint: "claude-3-haiku" },
     { key: "openrouter", label: "OpenRouter", hint: "multi-provider" },
     { key: "requesty", label: "Requesty", hint: "multi-provider" },
+    { key: "apiroute", label: "API Route", hint: "multi-provider" },
     { key: "atlascloud", label: "Atlas Cloud", hint: "DeepSeek V3.2" },
     { key: "custom", label: "Custom endpoint", hint: "OpenAI-compatible" },
     { key: "disable", label: "Disable LLM", hint: "free heuristic mode", color: COLORS.warning },
@@ -290001,6 +290624,7 @@ function getDefaultModel(provider2) {
   if (provider2 === "anthropic") return "claude-3-haiku-20240307";
   if (provider2 === "openrouter") return "openai/gpt-4o-mini";
   if (provider2 === "requesty") return "openai/gpt-4o-mini";
+  if (provider2 === "apiroute") return "deepseek-v4.1-flash";
   if (provider2 === "atlascloud") return "deepseek-ai/deepseek-v3.2";
   return "gpt-4o-mini";
 }
@@ -293558,14 +294182,14 @@ var main2 = defineCommand({
     search: () => Promise.resolve(defineCommand({
       meta: { name: "search", description: "Shortcut for `memorix memory search`" },
       args: {
-        query: { type: "positional", description: "Search query", required: true },
+        query: { type: "string", description: "Search query (also accepts the first positional argument)", required: false },
         limit: { type: "string", description: "Maximum results" },
         quality: { type: "string", description: "Retrieval profile: fast, balanced (default), or thorough" },
         json: { type: "boolean", description: "Emit machine-readable JSON output" }
       },
       async run({ args }) {
         await runMemoryShortcut("search", {
-          query: args.query,
+          query: args.query ?? args._?.[0],
           limit: args.limit,
           quality: args.quality,
           json: args.json