memorix 1.3.3 → 1.4.0

package/dist/sdk.js

@@ -1186,8 +1186,8 @@ async function acquireLock(lockPath) {
       const code = err instanceof Error && "code" in err ? err.code : void 0;
       if (code === "EEXIST" || code === "EPERM") {
         try {
-          const stat3 = await fs2.stat(lockPath);
-          if (Date.now() - stat3.mtimeMs > LOCK_STALE_MS) {
+          const stat4 = await fs2.stat(lockPath);
+          if (Date.now() - stat4.mtimeMs > LOCK_STALE_MS) {
             await fs2.unlink(lockPath).catch(() => {
             });
             continue;
@@ -9347,6 +9347,10 @@ var init_media_store = __esm({
       `).run(projectId, assetId).changes ?? 0);
           this.db.prepare("DELETE FROM media_derivations WHERE project_id = ? AND asset_id = ?").run(projectId, assetId);
           this.db.prepare("DELETE FROM media_embeddings WHERE project_id = ? AND asset_id = ?").run(projectId, assetId);
+          this.db.prepare(`
+        UPDATE media_jobs SET asset_id = NULL, updated_at = ?
+        WHERE project_id = ? AND asset_id = ?
+      `).run(Date.now(), projectId, assetId);
           const result = this.db.prepare(`
         UPDATE media_assets SET deleted_at = ?, updated_at = ?
         WHERE project_id = ? AND id = ? AND deleted_at IS NULL
@@ -9521,16 +9525,28 @@ var init_media_store = __esm({
         return row ? rowToJob2(row) : void 0;
       }
       updateJob(projectId, id, input) {
+        const updated = this.updateJobInternal(projectId, id, input, false);
+        if (!updated) throw new Error(`Media job not found: ${id}`);
+        return updated;
+      }
+      /**
+       * Atomically preserve a user cancellation against a worker that was already
+       * downloading or attaching media when the cancellation arrived.
+       */
+      updateJobIfNotCancelled(projectId, id, input) {
+        return this.updateJobInternal(projectId, id, input, true);
+      }
+      updateJobInternal(projectId, id, input, rejectCancelled) {
         const existing = this.getJob(projectId, id);
-        if (!existing) throw new Error(`Media job not found: ${id}`);
+        if (!existing) return void 0;
         const now3 = Date.now();
         const attempts = existing.attempts + (input.incrementAttempts ? 1 : 0);
         const completedAt = input.status === "completed" ? now3 : null;
-        this.db.prepare(`
+        const result = this.db.prepare(`
       UPDATE media_jobs
       SET status = ?, provider_task_id = COALESCE(?, provider_task_id), asset_id = COALESCE(?, asset_id),
           last_error = ?, attempts = ?, updated_at = ?, completed_at = ?
-      WHERE project_id = ? AND id = ?
+      WHERE project_id = ? AND id = ? ${rejectCancelled ? "AND status <> 'cancelled'" : ""}
     `).run(
           input.status,
           input.providerTaskId ?? null,
@@ -9542,6 +9558,7 @@ var init_media_store = __esm({
           projectId,
           id
         );
+        if (Number(result.changes ?? 0) !== 1) return void 0;
         return this.getJob(projectId, id);
       }
       cancelJob(projectId, id) {
@@ -9591,6 +9608,7 @@ async function attachMediaAssetToObservation(input) {
     `MIME type: ${asset.mimeType}`,
     ...input.facts ?? []
   ];
+  const store = new MediaStore(input.dataDir);
   const result = await storeObservation({
     entityName: input.entityName?.trim() || sourceLabel4.replace(/\.[^.]+$/, "") || "media-asset",
     type: "discovery",
@@ -9603,13 +9621,15 @@ async function attachMediaAssetToObservation(input) {
     sourceDetail: "explicit",
     ...input.visibility ? { visibility: input.visibility } : {},
     ...input.createdByAgentId ? { createdByAgentId: input.createdByAgentId } : {},
-    ...input.visibilityReader ? { visibilityReader: input.visibilityReader } : {}
-  });
-  new MediaStore(input.dataDir).linkAsset({
-    projectId: input.projectId,
-    assetId: asset.id,
-    observationId: result.observation.id,
-    role: input.role ?? "attachment"
+    ...input.visibilityReader ? { visibilityReader: input.visibilityReader } : {},
+    onPersisted: (observation) => {
+      store.linkAsset({
+        projectId: input.projectId,
+        assetId: asset.id,
+        observationId: observation.id,
+        role: input.role ?? "attachment"
+      });
+    }
   });
   return result.observation;
 }
@@ -9637,6 +9657,7 @@ var init_types2 = __esm({
 var asset_store_exports = {};
 __export(asset_store_exports, {
   cleanupMediaQuota: () => cleanupMediaQuota,
+  cleanupMediaTrash: () => cleanupMediaTrash,
   getMediaAssetPath: () => getMediaAssetPath,
   importMediaBuffer: () => importMediaBuffer,
   importMediaFile: () => importMediaFile,
@@ -9644,7 +9665,7 @@ __export(asset_store_exports, {
   removeMediaAsset: () => removeMediaAsset
 });
 import { createHash as createHash4, randomUUID as randomUUID5 } from "crypto";
-import { copyFile, lstat, mkdir as mkdir3, open, readFile as readFile3, rename, rm, writeFile as writeFile3 } from "fs/promises";
+import { copyFile, lstat, mkdir as mkdir3, open, readFile as readFile3, readdir, rename, rm, stat, writeFile as writeFile3 } from "fs/promises";
 import path13 from "path";
 function mediaRoot(dataDir) {
   return path13.resolve(dataDir, "media");
@@ -9790,11 +9811,11 @@ async function importKnownMedia(input) {
 async function importMediaFile(input) {
   const maxBytes = input.maxBytes ?? DEFAULT_MAX_MEDIA_BYTES;
   const source = path13.resolve(input.filePath);
-  const stat3 = await lstat(source);
-  if (stat3.isSymbolicLink()) throw new Error("Media import does not follow symbolic links");
-  if (!stat3.isFile()) throw new Error("Media import accepts regular files only");
-  if (stat3.size <= 0) throw new Error("Media import rejects empty files");
-  if (stat3.size > maxBytes) throw new Error(`Media file is too large (${stat3.size} bytes; limit ${maxBytes})`);
+  const stat4 = await lstat(source);
+  if (stat4.isSymbolicLink()) throw new Error("Media import does not follow symbolic links");
+  if (!stat4.isFile()) throw new Error("Media import accepts regular files only");
+  if (stat4.size <= 0) throw new Error("Media import rejects empty files");
+  if (stat4.size > maxBytes) throw new Error(`Media file is too large (${stat4.size} bytes; limit ${maxBytes})`);
   const header = await readHeader(source);
   const detected = detectMedia(header);
   const sha256 = await sha256File(source);
@@ -9802,7 +9823,7 @@ async function importMediaFile(input) {
     dataDir: input.dataDir,
     projectId: input.projectId,
     sha256,
-    bytes: stat3.size,
+    bytes: stat4.size,
     detected,
     persist: (destination) => persistFile(source, destination),
     sourceKind: input.sourceKind ?? "import",
@@ -9865,16 +9886,58 @@ async function removeMediaAsset(input) {
   }
   await rm(stagedPath, { force: true }).catch(() => {
   });
-  return { asset, detachedLinks };
+  return { asset, detachedLinks, pendingDelete: await destinationExists(stagedPath) };
+}
+async function cleanupMediaTrash(dataDir) {
+  const root = mediaRoot(dataDir);
+  const trashDir = validateUnderRoot(root, path13.join(root, ".trash"));
+  let entries;
+  try {
+    entries = await readdir(trashDir);
+  } catch (error) {
+    if (error?.code === "ENOENT") return { reclaimedBytes: 0, pendingBytes: 0, pendingFiles: 0 };
+    throw error;
+  }
+  let reclaimedBytes = 0;
+  let pendingBytes = 0;
+  let pendingFiles = 0;
+  for (const name of entries) {
+    if (!name.endsWith(".pending-delete")) continue;
+    const candidate = validateUnderRoot(trashDir, path13.join(trashDir, name));
+    try {
+      const metadata = await lstat(candidate);
+      if (!metadata.isFile()) continue;
+      await rm(candidate, { force: true });
+      reclaimedBytes += metadata.size;
+    } catch (error) {
+      if (error?.code === "ENOENT") continue;
+      try {
+        pendingBytes += (await stat(candidate)).size;
+      } catch {
+      }
+      pendingFiles += 1;
+    }
+  }
+  return { reclaimedBytes, pendingBytes, pendingFiles };
 }
 async function cleanupMediaQuota(input) {
   const store = new MediaStore(input.dataDir);
   const maxBytes = input.maxBytes ?? DEFAULT_MEDIA_QUOTA_BYTES;
   if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new Error("maxBytes must be a non-negative integer");
+  const initialTrash = await cleanupMediaTrash(input.dataDir);
   const beforeBytes = store.activeByteSize(input.projectId);
   let currentBytes = beforeBytes;
   const removed = [];
-  if (currentBytes <= maxBytes) return { beforeBytes, afterBytes: currentBytes, removed };
+  if (currentBytes <= maxBytes) {
+    return {
+      beforeBytes,
+      afterBytes: currentBytes,
+      removed,
+      reclaimedTrashBytes: initialTrash.reclaimedBytes,
+      pendingTrashBytes: initialTrash.pendingBytes,
+      pendingTrashFiles: initialTrash.pendingFiles
+    };
+  }
   const candidates = store.listUnlinkedAssets(input.projectId);
   for (const asset of candidates) {
     if (currentBytes <= maxBytes) break;
@@ -9887,7 +9950,15 @@ async function cleanupMediaQuota(input) {
     currentBytes -= asset.byteSize;
     removed.push(asset);
   }
-  return { beforeBytes, afterBytes: Math.max(0, currentBytes), removed };
+  const finalTrash = await cleanupMediaTrash(input.dataDir);
+  return {
+    beforeBytes,
+    afterBytes: Math.max(0, currentBytes),
+    removed,
+    reclaimedTrashBytes: initialTrash.reclaimedBytes + finalTrash.reclaimedBytes,
+    pendingTrashBytes: finalTrash.pendingBytes,
+    pendingTrashFiles: finalTrash.pendingFiles
+  };
 }
 var init_asset_store = __esm({
   "src/media/asset-store.ts"() {
@@ -60894,7 +60965,7 @@ var require_node_domexception = __commonJS({
 // node_modules/fetch-blob/from.js
 import { statSync as statSync2, createReadStream, promises as fs10 } from "fs";
 import { basename } from "path";
-var import_node_domexception, stat, blobFromSync, blobFrom, fileFrom, fileFromSync, fromBlob, fromFile, BlobDataItem;
+var import_node_domexception, stat2, blobFromSync, blobFrom, fileFrom, fileFromSync, fromBlob, fromFile, BlobDataItem;
 var init_from = __esm({
   "node_modules/fetch-blob/from.js"() {
     "use strict";
@@ -60902,23 +60973,23 @@ var init_from = __esm({
     import_node_domexception = __toESM(require_node_domexception(), 1);
     init_file();
     init_fetch_blob();
-    ({ stat } = fs10);
+    ({ stat: stat2 } = fs10);
     blobFromSync = (path33, type) => fromBlob(statSync2(path33), path33, type);
-    blobFrom = (path33, type) => stat(path33).then((stat3) => fromBlob(stat3, path33, type));
-    fileFrom = (path33, type) => stat(path33).then((stat3) => fromFile(stat3, path33, type));
+    blobFrom = (path33, type) => stat2(path33).then((stat4) => fromBlob(stat4, path33, type));
+    fileFrom = (path33, type) => stat2(path33).then((stat4) => fromFile(stat4, path33, type));
     fileFromSync = (path33, type) => fromFile(statSync2(path33), path33, type);
-    fromBlob = (stat3, path33, type = "") => new fetch_blob_default([new BlobDataItem({
+    fromBlob = (stat4, path33, type = "") => new fetch_blob_default([new BlobDataItem({
       path: path33,
-      size: stat3.size,
-      lastModified: stat3.mtimeMs,
+      size: stat4.size,
+      lastModified: stat4.mtimeMs,
       start: 0
     })], { type });
-    fromFile = (stat3, path33, type = "") => new file_default([new BlobDataItem({
+    fromFile = (stat4, path33, type = "") => new file_default([new BlobDataItem({
       path: path33,
-      size: stat3.size,
-      lastModified: stat3.mtimeMs,
+      size: stat4.size,
+      lastModified: stat4.mtimeMs,
       start: 0
-    })], basename(path33), { type, lastModified: stat3.mtimeMs });
+    })], basename(path33), { type, lastModified: stat4.mtimeMs });
     BlobDataItem = class _BlobDataItem {
       #path;
       #start;
@@ -60941,7 +61012,7 @@ var init_from = __esm({
         });
       }
       async *stream() {
-        const { mtimeMs } = await stat(this.#path);
+        const { mtimeMs } = await stat2(this.#path);
         if (mtimeMs > this.lastModified) {
           throw new import_node_domexception.default("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.", "NotReadableError");
         }
@@ -143218,10 +143289,17 @@ function sourceLabel2(request, providerTaskId) {
 }
 async function finishWithAsset(input) {
   const { dataDir, projectId, store, mediaJob, request, providerTask, dependencies } = input;
-  let asset = mediaJob.assetId ? store.getAsset(projectId, mediaJob.assetId) : void 0;
+  let activeJob = store.getJob(projectId, mediaJob.id);
+  if (!activeJob || terminal(activeJob)) return { action: "complete" };
+  let asset = activeJob.assetId ? store.getAsset(projectId, activeJob.assetId) : void 0;
   if (!asset) {
     if (!providerTask.downloadUrl) throw new Error("Succeeded MiniMax video task did not include a download URL");
-    store.updateJob(projectId, mediaJob.id, { status: "downloading", providerTaskId: providerTask.taskId });
+    const downloading = store.updateJobIfNotCancelled(projectId, activeJob.id, {
+      status: "downloading",
+      providerTaskId: providerTask.taskId
+    });
+    if (!downloading) return { action: "complete" };
+    activeJob = downloading;
     const bytes = await (dependencies.download ?? ((downloadInput) => downloadProviderMedia(downloadInput)))({
       url: providerTask.downloadUrl,
       maxBytes: request.maxBytes
@@ -143238,21 +143316,30 @@ async function finishWithAsset(input) {
       maxBytes: request.maxBytes
     });
     asset = imported.asset;
+    const persistedAsset = store.updateJobIfNotCancelled(projectId, activeJob.id, {
+      status: "downloading",
+      providerTaskId: providerTask.taskId,
+      assetId: asset.id
+    });
+    if (!persistedAsset) return { action: "complete" };
+    activeJob = persistedAsset;
   }
-  if (mediaJob.attachOnComplete) {
+  if (activeJob.attachOnComplete) {
+    activeJob = store.getJob(projectId, activeJob.id);
+    if (!activeJob || terminal(activeJob)) return { action: "complete" };
     const hasAttachment = store.listLinks(projectId, asset.id).some((link) => link.role === "attachment" && link.observationId !== void 0);
     if (!hasAttachment) {
       await (dependencies.attach ?? attachMediaAssetToObservation)({
         dataDir,
         projectId,
         asset,
-        title: mediaJob.observationTitle ?? `MiniMax video: ${asset.sourceLabel ?? asset.id}`,
+        title: activeJob.observationTitle ?? `MiniMax video: ${asset.sourceLabel ?? asset.id}`,
         narrative: `Generated with ${request.provider}/${request.model}. Prompt: ${request.prompt}`,
         concepts: ["generated-video", "minimax", request.model]
       });
     }
   }
-  store.updateJob(projectId, mediaJob.id, {
+  store.updateJobIfNotCancelled(projectId, activeJob.id, {
     status: "completed",
     providerTaskId: providerTask.taskId,
     assetId: asset.id
@@ -143262,10 +143349,12 @@ async function finishWithAsset(input) {
 function retryAfterProviderError(store, projectId, mediaJob, maintenanceJob, error) {
   const message = safeError2(error);
   if (maintenanceJob.attempts >= maintenanceJob.maxAttempts) {
-    store.updateJob(projectId, mediaJob.id, { status: "failed", lastError: message, incrementAttempts: true });
+    store.updateJobIfNotCancelled(projectId, mediaJob.id, { status: "failed", lastError: message, incrementAttempts: true });
+    return { action: "complete" };
+  }
+  if (!store.updateJobIfNotCancelled(projectId, mediaJob.id, { status: "retry", lastError: message, incrementAttempts: true })) {
     return { action: "complete" };
   }
-  store.updateJob(projectId, mediaJob.id, { status: "retry", lastError: message, incrementAttempts: true });
   return { action: "reschedule", delayMs: MINI_MAX_VIDEO_POLL_MS, status: "retry", lastError: message };
 }
 function queueMiniMaxVideoGeneration(input) {
@@ -143306,22 +143395,25 @@ async function runMiniMaxVideoGenerationJob(maintenanceJob, context, dependencie
   if (mediaJob.kind !== "minimax-video-generation") throw new Error(`Unsupported media job kind: ${mediaJob.kind}`);
   const request = parseStoredRequest(mediaJob.request);
   if (!mediaJob.providerTaskId) {
-    store.updateJob(context.projectId, mediaJob.id, { status: "submitting", incrementAttempts: true });
+    if (!store.updateJobIfNotCancelled(context.projectId, mediaJob.id, { status: "submitting", incrementAttempts: true })) {
+      return { action: "complete" };
+    }
     let submitted;
     try {
       submitted = await (dependencies.createTask ?? createMiniMaxVideoTask)(toVideoRequest(request));
     } catch (error) {
-      store.updateJob(context.projectId, mediaJob.id, { status: "failed", lastError: safeError2(error) });
+      store.updateJobIfNotCancelled(context.projectId, mediaJob.id, { status: "failed", lastError: safeError2(error) });
       return { action: "complete" };
     }
     if (submitted.status === "failed") {
-      store.updateJob(context.projectId, mediaJob.id, { status: "failed", providerTaskId: submitted.taskId, lastError: submitted.error });
+      store.updateJobIfNotCancelled(context.projectId, mediaJob.id, { status: "failed", providerTaskId: submitted.taskId, lastError: submitted.error });
       return { action: "complete" };
     }
-    const pending = store.updateJob(context.projectId, mediaJob.id, {
+    const pending = store.updateJobIfNotCancelled(context.projectId, mediaJob.id, {
       status: submitted.status === "succeeded" ? "downloading" : "provider-pending",
       providerTaskId: submitted.taskId
     });
+    if (!pending) return { action: "complete" };
     if (submitted.status === "succeeded") {
       try {
         return await finishWithAsset({
@@ -143349,11 +143441,13 @@ async function runMiniMaxVideoGenerationJob(maintenanceJob, context, dependencie
     return retryAfterProviderError(store, context.projectId, mediaJob, maintenanceJob, error);
   }
   if (task.status === "pending") {
-    store.updateJob(context.projectId, mediaJob.id, { status: "provider-pending", providerTaskId: task.taskId });
+    if (!store.updateJobIfNotCancelled(context.projectId, mediaJob.id, { status: "provider-pending", providerTaskId: task.taskId })) {
+      return { action: "complete" };
+    }
     return { action: "reschedule", delayMs: MINI_MAX_VIDEO_POLL_MS, resetAttempts: true, clearLastError: true };
   }
   if (task.status === "failed") {
-    store.updateJob(context.projectId, mediaJob.id, { status: "failed", providerTaskId: task.taskId, lastError: task.error, incrementAttempts: true });
+    store.updateJobIfNotCancelled(context.projectId, mediaJob.id, { status: "failed", providerTaskId: task.taskId, lastError: task.error, incrementAttempts: true });
     return { action: "complete" };
   }
   try {
@@ -144636,7 +144730,7 @@ function indexFileLite(projectId, projectRoot, abs, indexedAt, fileStat) {
   const rel = normalizeCodePath(relative(projectRoot, abs));
   try {
     const text = readFileSync6(abs, "utf-8");
-    const stat3 = fileStat ?? statSync3(abs);
+    const stat4 = fileStat ?? statSync3(abs);
     const file = {
       id: makeCodeFileId(projectId, rel),
       projectId,
@@ -144645,8 +144739,8 @@ function indexFileLite(projectId, projectRoot, abs, indexedAt, fileStat) {
       contentHash: hashText(text),
       // Preserve filesystem precision. Rounding here made same-size edits in
       // a short Windows timestamp window indistinguishable to refresh.
-      mtimeMs: Number(stat3.mtimeMs),
-      sizeBytes: Number(stat3.size),
+      mtimeMs: Number(stat4.mtimeMs),
+      sizeBytes: Number(stat4.size),
       indexedAt
     };
     return {
@@ -144673,18 +144767,18 @@ async function indexProjectLite(options) {
   let skippedOversizedFiles = 0;
   let unreadableFiles = 0;
   for (const abs of paths) {
-    let stat3;
+    let stat4;
     try {
-      stat3 = statSync3(abs);
+      stat4 = statSync3(abs);
     } catch {
       unreadableFiles++;
       continue;
     }
-    if (Number(stat3.size) > maxFileBytes) {
+    if (Number(stat4.size) > maxFileBytes) {
       skippedOversizedFiles++;
       continue;
     }
-    const attempt = indexFileLite(options.projectId, options.projectRoot, abs, indexedAt, stat3);
+    const attempt = indexFileLite(options.projectId, options.projectRoot, abs, indexedAt, stat4);
     if (!attempt.delta) {
       if (attempt.unreadable) unreadableFiles++;
       continue;
@@ -144712,16 +144806,16 @@ async function refreshProjectLite(store, options) {
   for (const abs of paths) {
     const rel = normalizeCodePath(relative(options.projectRoot, abs));
     seenPaths.add(rel);
-    let stat3;
+    let stat4;
     try {
-      stat3 = statSync3(abs);
+      stat4 = statSync3(abs);
     } catch {
       unreadableFiles++;
       continue;
     }
     const existing = existingByPath.get(rel);
-    const mtimeMs = Number(stat3.mtimeMs);
-    const sizeBytes = Number(stat3.size);
+    const mtimeMs = Number(stat4.mtimeMs);
+    const sizeBytes = Number(stat4.size);
     if (sizeBytes > maxFileBytes) {
       skippedOversizedFiles++;
       if (existing) oversizedExistingFileIds.add(existing.id);
@@ -144731,7 +144825,7 @@ async function refreshProjectLite(store, options) {
       unchangedFiles++;
       continue;
     }
-    const attempt = indexFileLite(options.projectId, options.projectRoot, abs, indexedAt, stat3);
+    const attempt = indexFileLite(options.projectId, options.projectRoot, abs, indexedAt, stat4);
     if (!attempt.delta) {
       if (attempt.unreadable) unreadableFiles++;
       continue;
@@ -148513,7 +148607,9 @@ async function storeObservation(input) {
       if (input.visibilityReader && !canManageObservation(existing, input.visibilityReader)) {
         throw new Error("Cannot update a memory outside this session's write scope.");
       }
-      return { observation: await upsertObservation(existing, input, now3), upserted: true };
+      const observation2 = await upsertObservation(existing, input, now3);
+      await input.onPersisted?.(observation2);
+      return { observation: observation2, upserted: true };
     }
   }
   const contentForExtraction = [input.title, input.narrative, ...input.facts ?? []].join(" ");
@@ -148538,6 +148634,7 @@ async function storeObservation(input) {
   let doc;
   let upsertedInsideLock = false;
   let reloadCacheAfterCommit = false;
+  let persistedCallbackInvoked = false;
   const assignAndPersist = async () => {
     if (projectDir) {
       const store = getObservationStore();
@@ -148593,6 +148690,8 @@ async function storeObservation(input) {
           writeGeneration: transactionGeneration + 1
         };
         await tx.insert(observation);
+        await input.onPersisted?.(observation);
+        persistedCallbackInvoked = true;
         await tx.saveIdCounter(id + 1);
       });
       observation.writeGeneration = store.getGeneration();
@@ -148642,6 +148741,8 @@ async function storeObservation(input) {
         writeGeneration: 0
       };
       observations.push(observation);
+      await input.onPersisted?.(observation);
+      persistedCallbackInvoked = true;
     }
     doc = {
       id: makeOramaObservationId(input.projectId, observation.id),
@@ -148673,8 +148774,11 @@ async function storeObservation(input) {
   };
   await assignAndPersist();
   if (upsertedInsideLock) {
-    return { observation: await upsertObservation(observation, input, now3), upserted: true };
+    const updated = await upsertObservation(observation, input, now3);
+    await input.onPersisted?.(updated);
+    return { observation: updated, upserted: true };
   }
+  if (!persistedCallbackInvoked) await input.onPersisted?.(observation);
   await bindObservationCodeRefsBestEffort(observation);
   queueObservationQualification(observation);
   if (resolveObservationVisibility(observation) === "project") {
@@ -153826,9 +153930,9 @@ function existingLensCandidates(rootPath, lens) {
     const absolute = path27.join(rootPath, candidate);
     try {
       if (!existsSync15(absolute)) continue;
-      const stat3 = statSync4(absolute);
-      if (stat3.isFile()) out.push(candidate);
-      if (stat3.isDirectory()) out.push(candidate.replace(/\\/g, "/"));
+      const stat4 = statSync4(absolute);
+      if (stat4.isFile()) out.push(candidate);
+      if (stat4.isDirectory()) out.push(candidate.replace(/\\/g, "/"));
     } catch {
     }
   }
@@ -159965,11 +160069,11 @@ import path32 from "path";
 function resolveGitDir(projectRoot) {
   const dotGit = path32.join(projectRoot, ".git");
   if (!existsSync18(dotGit)) return null;
-  const stat3 = statSync5(dotGit);
-  if (stat3.isDirectory()) {
+  const stat4 = statSync5(dotGit);
+  if (stat4.isDirectory()) {
     return dotGit;
   }
-  if (stat3.isFile()) {
+  if (stat4.isFile()) {
     try {
       const content = readFileSync13(dotGit, "utf-8").trim();
       const match2 = content.match(/^gitdir:\s*(.+)$/);
@@ -162007,8 +162111,8 @@ var RulesSyncer = class {
     const dir = path23.dirname(pattern);
     const fileGlob = path23.basename(pattern);
     try {
-      const stat3 = await fs16.stat(dir);
-      if (!stat3.isDirectory()) {
+      const stat4 = await fs16.stat(dir);
+      if (!stat4.isDirectory()) {
         try {
           await fs16.access(pattern);
           return [pattern];
@@ -163473,18 +163577,21 @@ var TOOL_PROFILES = Object.freeze({
   memorix_context_pack: ["micro", "lite", "team", "full"],
   memorix_codegraph_status: ["micro", "lite", "team", "full"],
   memorix_resolve: ["micro", "lite", "team", "full"],
+  // A fail-closed stdio server needs an explicit recovery path when a client
+  // did not launch it from the workspace. The unified media tool keeps
+  // multimodal support to one additional schema rather than enabling lite.
+  memorix_session_start: ["micro", "lite", "team", "full"],
+  memorix_media: ["micro", "lite", "team", "full"],
   // ── lite: extended solo memory surface ────────────────────────────
   memorix_graph_context: ["lite", "team", "full"],
   memorix_timeline: ["lite", "team", "full"],
   memorix_suggest_topic_key: ["lite", "team", "full"],
-  memorix_session_start: ["lite", "team", "full"],
   memorix_session_end: ["lite", "team", "full"],
   memorix_session_context: ["lite", "team", "full"],
   memorix_store_reasoning: ["lite", "team", "full"],
   memorix_search_reasoning: ["lite", "team", "full"],
   memorix_transfer: ["lite", "team", "full"],
   memorix_retention: ["lite", "team", "full"],
-  memorix_media: ["lite", "team", "full"],
   // ── team: orchestration coordination surfaces — HTTP default ──────
   memorix_dashboard: ["team", "full"],
   memorix_knowledge: ["team", "full"],
@@ -163537,7 +163644,7 @@ function resolveToolProfile(opts) {
 function describeProfile(profile) {
   switch (profile) {
     case "micro":
-      return "micro (agent-ready context + basic memory, ~7 tools)";
+      return "micro (agent-ready context + bounded recovery/media, ~9 tools)";
     case "lite":
       return "lite (core memory + sessions, ~18 tools)";
     case "team":
@@ -164022,7 +164129,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.3.3" : "1.0.1"
+    version: true ? "1.4.0" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -167709,9 +167816,9 @@ ${lines.join("\n")}` }] };
     "memorix_media",
     {
       title: "Manage Controlled Media",
-      description: "Use the controlled local media library for an explicit import, attachment, inspection, or MiniMax generation request. Assets stay outside the Git worktree and enter normal memory only when attach is explicitly true. Use the CLI for destructive removal, quota cleanup, job cancellation, and direct generation. MCP generation is disabled by default and requires MEMORIX_MCP_MEDIA_GENERATION=1 after the operator reviews provider billing.",
+      description: "Use the controlled local media library for an explicit import, attachment, inspection, or MiniMax generation request. Assets stay outside the Git worktree and enter normal memory only when attach is explicitly true. Use the CLI for destructive removal, quota cleanup, and direct generation. MCP generation is disabled by default and requires MEMORIX_MCP_MEDIA_GENERATION=1 after the operator reviews provider billing.",
       inputSchema: {
-        action: z626.enum(["import", "attach", "list", "show", "generate-image", "generate-video", "status"]),
+        action: z626.enum(["import", "attach", "list", "show", "generate-image", "generate-video", "status", "cancel"]),
         path: z626.string().optional().describe("Explicit local image/audio/video/PDF path for import."),
         assetId: z626.string().optional().describe("Controlled MediaAsset ID for attach/show."),
         jobId: z626.string().optional().describe("Durable media job ID for status."),
@@ -167783,6 +167890,10 @@ ${lines.join("\n")}` }] };
           if (!job) throw new Error(`Media job not found: ${jobId}`);
           return result({ action, projectId: project.id, job });
         }
+        if (action === "cancel") {
+          if (!jobId?.trim()) throw new Error("jobId is required for media cancel");
+          return result({ action, projectId: project.id, job: store.cancelJob(project.id, jobId) });
+        }
         if (action === "attach") {
           if (!assetId?.trim()) throw new Error("assetId is required for media attach");
           const asset = store.getAsset(project.id, assetId);