memorix 1.3.3 → 1.4.0

package/src/media/media-store.ts

@@ -242,6 +242,13 @@ export class MediaStore {
       `).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);
+      // Assets are soft-deleted so SQLite's ON DELETE SET NULL does not fire.
+      // Do not leave completed jobs advertising an asset that `media show` can
+      // no longer retrieve.
+      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
@@ -431,16 +438,42 @@ export class MediaStore {
     lastError?: string;
     incrementAttempts?: boolean;
   }): MediaJob {
+    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: string, id: string, input: {
+    status: MediaJobStatus;
+    providerTaskId?: string;
+    assetId?: string;
+    lastError?: string;
+    incrementAttempts?: boolean;
+  }): MediaJob | undefined {
+    return this.updateJobInternal(projectId, id, input, true);
+  }
+
+  private updateJobInternal(projectId: string, id: string, input: {
+    status: MediaJobStatus;
+    providerTaskId?: string;
+    assetId?: string;
+    lastError?: string;
+    incrementAttempts?: boolean;
+  }, rejectCancelled: boolean): MediaJob | undefined {
     const existing = this.getJob(projectId, id);
-    if (!existing) throw new Error(`Media job not found: ${id}`);
+    if (!existing) return undefined;
     const now = Date.now();
     const attempts = existing.attempts + (input.incrementAttempts ? 1 : 0);
     const completedAt = input.status === 'completed' ? now : 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,
@@ -452,7 +485,8 @@ export class MediaStore {
       projectId,
       id,
     );
-    return this.getJob(projectId, id)!;
+    if (Number(result.changes ?? 0) !== 1) return undefined;
+    return this.getJob(projectId, id);
   }
 
   cancelJob(projectId: string, id: string): MediaJob {

package/src/media/video-jobs.ts

@@ -139,12 +139,19 @@ async function finishWithAsset(input: {
   dependencies: MediaVideoGenerationDependencies;
 }): Promise<MaintenanceJobRunResult> {
   const { dataDir, projectId, store, mediaJob, request, providerTask, dependencies } = input;
-  let asset: MediaAsset | undefined = mediaJob.assetId
-    ? store.getAsset(projectId, mediaJob.assetId)
+  let activeJob = store.getJob(projectId, mediaJob.id);
+  if (!activeJob || terminal(activeJob)) return { action: 'complete' };
+  let asset: MediaAsset | undefined = activeJob.assetId
+    ? store.getAsset(projectId, activeJob.assetId)
     : undefined;
   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,
@@ -161,9 +168,20 @@ async function finishWithAsset(input: {
       maxBytes: request.maxBytes,
     });
     asset = imported.asset;
+    // Persist the local result before optional attachment. A later retry can
+    // resume attachment even if the provider's signed URL has expired.
+    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 !== undefined);
     if (!hasAttachment) {
@@ -171,13 +189,13 @@ async function finishWithAsset(input: {
         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,
@@ -194,10 +212,12 @@ function retryAfterProviderError(
 ): MaintenanceJobRunResult {
   const message = safeError(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 };
 }
 
@@ -250,24 +270,27 @@ export async function runMiniMaxVideoGenerationJob(
   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: MiniMaxVideoTask;
     try {
       submitted = await (dependencies.createTask ?? createMiniMaxVideoTask)(toVideoRequest(request));
     } catch (error) {
       // A submit timeout can mean the provider accepted a billable request. Do
       // not retry automatically without a task ID; the operator can resubmit.
-      store.updateJob(context.projectId, mediaJob.id, { status: 'failed', lastError: safeError(error) });
+      store.updateJobIfNotCancelled(context.projectId, mediaJob.id, { status: 'failed', lastError: safeError(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({
@@ -296,11 +319,13 @@ export async function runMiniMaxVideoGenerationJob(
     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 {

package/src/memory/observations.ts

@@ -397,6 +397,12 @@ export async function storeObservation(input: {
   createdByAgentId?: string;
   /** Optional caller-bound write scope for topic-key upserts. */
   visibilityReader?: ObservationReader;
+  /**
+   * Internal transaction callback for a second SQLite record that must either
+   * commit with this observation or not exist at all. It is intentionally not
+   * exposed through the SDK input surface.
+   */
+  onPersisted?: (observation: Observation) => void | Promise<void>;
 }): Promise<{ observation: Observation; upserted: boolean }> {
   const now = new Date().toISOString();
 
@@ -431,7 +437,9 @@ export 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, now), upserted: true };
+      const observation = await upsertObservation(existing, input, now);
+      await input.onPersisted?.(observation);
+      return { observation, upserted: true };
     }
   }
 
@@ -460,6 +468,7 @@ export async function storeObservation(input: {
 
   let upsertedInsideLock = false;
   let reloadCacheAfterCommit = false;
+  let persistedCallbackInvoked = false;
   const assignAndPersist = async () => {
     if (projectDir) {
       const store = getObservationStore();
@@ -528,6 +537,8 @@ export async function storeObservation(input: {
         };
 
         await tx.insert(observation);
+        await input.onPersisted?.(observation);
+        persistedCallbackInvoked = true;
         await tx.saveIdCounter(id + 1);
       });
 
@@ -584,6 +595,8 @@ export async function storeObservation(input: {
         writeGeneration: 0,
       };
       observations.push(observation);
+      await input.onPersisted?.(observation);
+      persistedCallbackInvoked = true;
     }
 
     // Build Orama doc AFTER id is assigned
@@ -621,9 +634,15 @@ export async function storeObservation(input: {
 
   // If the lock discovered a topicKey duplicate on disk, delegate to upsert
   if (upsertedInsideLock) {
-    return { observation: await upsertObservation(observation, input, now), upserted: true };
+    const updated = await upsertObservation(observation, input, now);
+    await input.onPersisted?.(updated);
+    return { observation: updated, upserted: true };
   }
 
+  // The normal persistent path invokes the callback inside the SQLite
+  // transaction. Keep the in-memory fallback defensively covered too.
+  if (!persistedCallbackInvoked) await input.onPersisted?.(observation);
+
   await bindObservationCodeRefsBestEffort(observation);
   queueObservationQualification(observation);
   if (resolveObservationVisibility(observation) === 'project') {

package/src/orchestrate/adapters/spawn-helper.ts

@@ -43,6 +43,7 @@ export function spawnAgent(
     stdio: [stdinData ? 'pipe' : 'ignore', 'pipe', 'pipe'],
     // Windows: use shell to resolve CLI tools on PATH
     shell: process.platform === 'win32',
+    windowsHide: true,
   });
 
   // Write prompt via stdin to avoid shell argument escaping issues.
@@ -134,6 +135,7 @@ export function spawnAgentWithStream(
     env: { ...process.env, ...opts.env },
     stdio: [stdinData ? 'pipe' : 'ignore', 'pipe', 'pipe'],
     shell: process.platform === 'win32',
+    windowsHide: true,
   });
 
   let stdinError: string | undefined;

package/src/server/tool-profile.ts

@@ -6,7 +6,7 @@
  * tools/list time causes cognitive overload.
  *
  * We provide four profiles:
- *   - "micro" (stdio default): Agent-ready project context + basic memory CRUD — 7 tools.
+ *   - "micro" (stdio default): Agent-ready project context + bounded recovery/media controls — 9 tools.
  *     Suitable for normal MCP clients where every tool schema costs context tokens.
  *   - "lite": Core memory CRUD, sessions, reasoning, retention, backup — 18 tools.
  *     Suitable for solo users who want the full memory surface without team tools.
@@ -35,19 +35,22 @@ export const TOOL_PROFILES: Record<string, ReadonlyArray<ToolProfile>> = Object.
   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'],
@@ -136,7 +139,7 @@ export function resolveToolProfile(opts: ResolveToolProfileOpts): ToolProfile {
  */
 export function describeProfile(profile: ToolProfile): string {
   switch (profile) {
-    case 'micro': return 'micro (agent-ready context + basic memory, ~7 tools)';
+    case 'micro': return 'micro (agent-ready context + bounded recovery/media, ~9 tools)';
     case 'lite': return 'lite (core memory + sessions, ~18 tools)';
     case 'team': return 'team (lite + coordination tools + dashboard + knowledge workspace, ~26 tools)';
     case 'full': return 'full (all tools including advanced / KG-compat)';

package/src/server.ts

@@ -4993,10 +4993,10 @@ export async function createMemorixServer(
       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. ' +
+        '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: z.enum(['import', 'attach', 'list', 'show', 'generate-image', 'generate-video', 'status']),
+        action: z.enum(['import', 'attach', 'list', 'show', 'generate-image', 'generate-video', 'status', 'cancel']),
         path: z.string().optional().describe('Explicit local image/audio/video/PDF path for import.'),
         assetId: z.string().optional().describe('Controlled MediaAsset ID for attach/show.'),
         jobId: z.string().optional().describe('Durable media job ID for status.'),
@@ -5069,6 +5069,10 @@ export async function createMemorixServer(
           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);