memorix 1.3.3 → 1.3.4

package/dist/media-video-runner.js

@@ -1318,8 +1318,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;
@@ -7895,6 +7895,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
@@ -8069,16 +8073,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,
@@ -8090,6 +8106,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) {
@@ -8135,6 +8152,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() || sourceLabel2.replace(/\.[^.]+$/, "") || "media-asset",
     type: "discovery",
@@ -8147,13 +8165,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;
 }
@@ -8179,7 +8199,7 @@ var init_types2 = __esm({
 
 // src/media/asset-store.ts
 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 path9 from "path";
 function mediaRoot(dataDir) {
   return path9.resolve(dataDir, "media");
@@ -59292,7 +59312,7 @@ var require_node_domexception = __commonJS({
 // node_modules/fetch-blob/from.js
 import { statSync as statSync2, createReadStream, promises as fs7 } 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";
@@ -59300,23 +59320,23 @@ var init_from = __esm({
     import_node_domexception = __toESM(require_node_domexception(), 1);
     init_file();
     init_fetch_blob();
-    ({ stat } = fs7);
+    ({ stat: stat2 } = fs7);
     blobFromSync = (path19, type) => fromBlob(statSync2(path19), path19, type);
-    blobFrom = (path19, type) => stat(path19).then((stat3) => fromBlob(stat3, path19, type));
-    fileFrom = (path19, type) => stat(path19).then((stat3) => fromFile(stat3, path19, type));
+    blobFrom = (path19, type) => stat2(path19).then((stat4) => fromBlob(stat4, path19, type));
+    fileFrom = (path19, type) => stat2(path19).then((stat4) => fromFile(stat4, path19, type));
     fileFromSync = (path19, type) => fromFile(statSync2(path19), path19, type);
-    fromBlob = (stat3, path19, type = "") => new fetch_blob_default([new BlobDataItem({
+    fromBlob = (stat4, path19, type = "") => new fetch_blob_default([new BlobDataItem({
       path: path19,
-      size: stat3.size,
-      lastModified: stat3.mtimeMs,
+      size: stat4.size,
+      lastModified: stat4.mtimeMs,
       start: 0
     })], { type });
-    fromFile = (stat3, path19, type = "") => new file_default([new BlobDataItem({
+    fromFile = (stat4, path19, type = "") => new file_default([new BlobDataItem({
       path: path19,
-      size: stat3.size,
-      lastModified: stat3.mtimeMs,
+      size: stat4.size,
+      lastModified: stat4.mtimeMs,
       start: 0
-    })], basename(path19), { type, lastModified: stat3.mtimeMs });
+    })], basename(path19), { type, lastModified: stat4.mtimeMs });
     BlobDataItem = class _BlobDataItem {
       #path;
       #start;
@@ -59339,7 +59359,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");
         }
@@ -141505,10 +141525,17 @@ function sourceLabel(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
@@ -141525,21 +141552,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
@@ -141549,10 +141585,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) {
@@ -141593,22 +141631,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({
@@ -141636,11 +141677,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 {
@@ -142923,7 +142966,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,
@@ -142932,8 +142975,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 {
@@ -142960,18 +143003,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;
@@ -142999,16 +143042,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);
@@ -143018,7 +143061,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;
@@ -146459,7 +146502,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(" ");
@@ -146484,6 +146529,7 @@ async function storeObservation(input) {
   let doc;
   let upsertedInsideLock = false;
   let reloadCacheAfterCommit = false;
+  let persistedCallbackInvoked = false;
   const assignAndPersist = async () => {
     if (projectDir) {
       const store = getObservationStore();
@@ -146539,6 +146585,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();
@@ -146588,6 +146636,8 @@ async function storeObservation(input) {
         writeGeneration: 0
       };
       observations.push(observation);
+      await input.onPersisted?.(observation);
+      persistedCallbackInvoked = true;
     }
     doc = {
       id: makeOramaObservationId(input.projectId, observation.id),
@@ -146619,8 +146669,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") {

package/dist/memcode-runtime/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.3.4] - 2026-08-02
+
+### Fixed
+- **Fail-closed project binding** -- Stdio and HTTP MCP servers no longer restore or keep writing a remembered project root. A launch without a reliable workspace now waits for an explicit root, MCP Roots, or `memorix_session_start`, preventing cross-project memory access.
+- **Portable MCP Roots** -- File URI roots now remain POSIX paths on Linux/macOS and convert correctly on Windows, including drive-letter paths and UNC roots.
+- **Atomic media attachments** -- A media retrieval observation and its asset link now commit in one SQLite transaction. If linking fails, no dangling observation survives. Completed video downloads also persist their local asset before a retryable attachment step.
+- **Authoritative video cancellation** -- A cancellation that lands while a video worker is downloading or finishing can no longer be overwritten back to `completed`; MCP can cancel an existing job even when new MCP media generation is disabled.
+- **Recoverable media cleanup** -- Files Windows cannot immediately release are visibly staged for retry, and media cleanup reports reclaimed or still-pending staged bytes instead of silently implying deletion succeeded.
+- **Non-destructive Codex migration** -- Legacy Codex hook cleanup now preserves customized hook files instead of deleting a file merely because its commands begin with `memorix hook`.
+- **One stdio runtime** -- Direct `node dist/index.js` invocation now delegates to `memorix serve`; importing the package no longer starts an MCP server as a side effect.
+
+### Changed
+- **Bounded default MCP surface** -- The `micro` profile exposes nine tools: agent-ready context, retrieval, one explicit session recovery path, and one controlled media operation. Advanced tools remain opt-in through higher profiles.
+
 ## [1.3.3] - 2026-08-02
 
 ### Added