@geminilight/mindos 0.6.30 → 0.6.32

package/app/lib/actions.ts

@@ -3,6 +3,7 @@
 import fs from 'fs';
 import path from 'path';
 import { createFile, deleteFile, deleteDirectory, convertToSpace, renameFile, renameSpace, getMindRoot, invalidateCache, collectAllFiles } from '@/lib/fs';
+import { moveToTrash, restoreFromTrash, restoreAsCopy, permanentlyDelete, listTrash, emptyTrash, purgeExpired, type TrashMeta } from '@/lib/core/trash';
 import { createSpaceFilesystem, generateReadmeTemplate } from '@/lib/core/create-space';
 import { INSTRUCTION_TEMPLATE, cleanDirName } from '@/lib/core/space-scaffold';
 import { revalidatePath } from 'next/cache';
@@ -25,7 +26,8 @@ export async function createFileAction(dirPath: string, fileName: string): Promi
 
 export async function deleteFileAction(filePath: string): Promise<{ success: boolean; error?: string }> {
   try {
-    deleteFile(filePath);
+    moveToTrash(getMindRoot(), filePath);
+    invalidateCache();
     revalidatePath('/', 'layout');
     return { success: true };
   } catch (err) {
@@ -59,7 +61,8 @@ export async function deleteFolderAction(
   dirPath: string,
 ): Promise<{ success: boolean; error?: string }> {
   try {
-    deleteDirectory(dirPath);
+    moveToTrash(getMindRoot(), dirPath);
+    invalidateCache();
     revalidatePath('/', 'layout');
     return { success: true };
   } catch (err) {
@@ -84,7 +87,8 @@ export async function deleteSpaceAction(
   spacePath: string,
 ): Promise<{ success: boolean; error?: string }> {
   try {
-    deleteDirectory(spacePath);
+    moveToTrash(getMindRoot(), spacePath);
+    invalidateCache();
     revalidatePath('/', 'layout');
     return { success: true };
   } catch (err) {
@@ -189,3 +193,53 @@ export async function cleanupExamplesAction(): Promise<{ success: boolean; delet
     return { success: false, deleted: 0, error: err instanceof Error ? err.message : 'Failed to cleanup' };
   }
 }
+
+// ─── Trash Actions ────────────────────────────────────────────────────────────
+
+export async function listTrashAction(): Promise<TrashMeta[]> {
+  // Purge expired items on each list call (lazy cleanup)
+  purgeExpired(getMindRoot());
+  return listTrash(getMindRoot());
+}
+
+export async function restoreFromTrashAction(
+  trashId: string,
+  mode: 'restore' | 'overwrite' | 'copy' = 'restore',
+): Promise<{ success: boolean; restoredPath?: string; error?: string; conflict?: boolean }> {
+  try {
+    const root = getMindRoot();
+    let result: { restoredPath: string };
+    if (mode === 'copy') {
+      result = restoreAsCopy(root, trashId);
+    } else {
+      result = restoreFromTrash(root, trashId, mode === 'overwrite');
+    }
+    invalidateCache();
+    revalidatePath('/', 'layout');
+    return { success: true, restoredPath: result.restoredPath };
+  } catch (err: unknown) {
+    const e = err as Error & { code?: string };
+    if (e.code === 'RESTORE_CONFLICT') {
+      return { success: false, error: e.message, conflict: true };
+    }
+    return { success: false, error: e.message ?? 'Failed to restore' };
+  }
+}
+
+export async function permanentlyDeleteAction(trashId: string): Promise<{ success: boolean; error?: string }> {
+  try {
+    permanentlyDelete(getMindRoot(), trashId);
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to delete' };
+  }
+}
+
+export async function emptyTrashAction(): Promise<{ success: boolean; count?: number; error?: string }> {
+  try {
+    const count = emptyTrash(getMindRoot());
+    return { success: true, count };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to empty trash' };
+  }
+}

package/app/lib/agent/stream-consumer.ts

@@ -16,6 +16,20 @@
  */
 import type { Message, MessagePart, ToolCallPart, TextPart, ReasoningPart } from '@/lib/types';
 
+/** Tools that modify files — trigger files-changed notification on completion */
+const FILE_MUTATING_TOOLS = new Set([
+  'write_file', 'create_file', 'batch_create_files',
+  'update_section', 'insert_after_heading', 'delete_file',
+  'rename_file', 'create_space',
+]);
+
+/** Notify the app that files were changed by the AI agent */
+function notifyFilesChanged() {
+  if (typeof window !== 'undefined') {
+    window.dispatchEvent(new Event('mindos:files-changed'));
+  }
+}
+
 export async function consumeUIMessageStream(
   body: ReadableStream<Uint8Array>,
   onUpdate: (message: Message) => void,
@@ -158,6 +172,10 @@ export async function consumeUIMessageStream(
               tc.output = output ?? '';
               tc.state = (event.isError ? 'error' : 'done');
               changed = true;
+              // Notify when a file-modifying tool completes successfully
+              if (!event.isError && FILE_MUTATING_TOOLS.has(tc.toolName)) {
+                notifyFilesChanged();
+              }
             }
             break;
           }

package/app/lib/agent/tools.ts

@@ -11,6 +11,7 @@ import { readSkillContentByName, scanSkillDirs } from '@/lib/pi-integration/skil
 import { callMcporterTool, createMcporterAgentTools, listMcporterServers, listMcporterTools } from '@/lib/pi-integration/mcporter';
 import { a2aTools } from '@/lib/a2a/a2a-tools';
 import { acpTools } from '@/lib/acp/acp-tools';
+import { buildLineDiff, collapseDiffContext } from '@/components/changes/line-diff';
 
 // Max chars per file to avoid token overflow (~100k chars ≈ ~25k tokens)
 const MAX_FILE_CHARS = 20_000;
@@ -39,6 +40,38 @@ function textResult(text: string): AgentToolResult<Record<string, never>> {
   return { content: [{ type: 'text', text }], details: {} as Record<string, never> };
 }
 
+/** Build a compact diff summary for tool output. Max 30 diff lines to avoid bloating agent context. */
+function buildDiffSummary(before: string, after: string): string {
+  if (before === after) return '';
+  // Skip diff for very large files — LCS is O(n*m), would block agent
+  const beforeLines = before.split('\n').length;
+  const afterLines = after.split('\n').length;
+  if (beforeLines > 2000 || afterLines > 2000) {
+    const added = Math.max(0, afterLines - beforeLines);
+    const removed = Math.max(0, beforeLines - afterLines);
+    return `(~+${added} ~−${removed}, ${afterLines} lines total)\n\n--- changes ---\n  (diff skipped — file too large)`;
+  }
+  const raw = buildLineDiff(before, after);
+  const inserts = raw.filter(r => r.type === 'insert').length;
+  const deletes = raw.filter(r => r.type === 'delete').length;
+  const stats = `+${inserts} −${deletes}`;
+  const collapsed = collapseDiffContext(raw, 2);
+  const MAX_DIFF_LINES = 30;
+  const lines: string[] = [];
+  for (const row of collapsed) {
+    if (lines.length >= MAX_DIFF_LINES) { lines.push('... (diff truncated)'); break; }
+    if (row.type === 'gap') { lines.push(`  ... ${row.count} lines unchanged ...`); continue; }
+    const prefix = row.type === 'insert' ? '+' : row.type === 'delete' ? '-' : ' ';
+    lines.push(`${prefix} ${row.text}`);
+  }
+  return `(${stats})\n\n--- changes ---\n${lines.join('\n')}`;
+}
+
+/** Safe read — returns empty string if file doesn't exist */
+function safeReadContent(filePath: string): string {
+  try { return getFileContent(filePath); } catch { return ''; }
+}
+
 /** Safe execute wrapper — catches all errors, returns error text (never throws) */
 function safeExecute<T>(
   fn: (toolCallId: string, params: T, signal?: AbortSignal) => Promise<AgentToolResult<any>>,
@@ -527,8 +560,10 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     description: 'Overwrite the entire content of an existing file. Use read_file first to see current content. Prefer update_section or insert_after_heading for partial edits.',
     parameters: WriteFileParams,
     execute: safeExecute(async (_id, params: Static<typeof WriteFileParams>) => {
+      const before = safeReadContent(params.path);
       saveFileContent(params.path, params.content);
-      return textResult(`File written: ${params.path}`);
+      const diff = buildDiffSummary(before, params.content);
+      return textResult(`File written: ${params.path}${diff ? ' ' + diff : ''}`);
     }),
   },
 
@@ -538,8 +573,10 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     description: 'Create a new file. Only .md and .csv files are allowed. Parent directories are created automatically. Does NOT create Space scaffolding (INSTRUCTION.md/README.md). Use create_space to create a Space.',
     parameters: CreateFileParams,
     execute: safeExecute(async (_id, params: Static<typeof CreateFileParams>) => {
-      createFile(params.path, params.content ?? '');
-      return textResult(`File created: ${params.path}`);
+      const content = params.content ?? '';
+      createFile(params.path, content);
+      const lineCount = content.split('\n').length;
+      return textResult(`File created: ${params.path} (+${lineCount})\n\n--- changes ---\n${content.split('\n').slice(0, 30).map(l => '+ ' + l).join('\n')}${lineCount > 30 ? '\n... (truncated)' : ''}`);
     }),
   },
 
@@ -571,8 +608,11 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     description: 'Append text to the end of an existing file. A blank line separator is added automatically.',
     parameters: AppendParams,
     execute: safeExecute(async (_id, params: Static<typeof AppendParams>) => {
+      const before = safeReadContent(params.path);
       appendToFile(params.path, params.content);
-      return textResult(`Content appended to: ${params.path}`);
+      const after = safeReadContent(params.path);
+      const diff = buildDiffSummary(before, after);
+      return textResult(`Content appended to: ${params.path}${diff ? ' ' + diff : ''}`);
     }),
   },
 
@@ -582,8 +622,11 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     description: 'Insert content right after a Markdown heading. Useful for adding items under a specific section. If heading matches fail, use edit_lines instead.',
     parameters: InsertHeadingParams,
     execute: safeExecute(async (_id, params: Static<typeof InsertHeadingParams>) => {
+      const before = safeReadContent(params.path);
       insertAfterHeading(params.path, params.heading, params.content);
-      return textResult(`Content inserted after heading "${params.heading}" in ${params.path}`);
+      const after = safeReadContent(params.path);
+      const diff = buildDiffSummary(before, after);
+      return textResult(`Content inserted after heading "${params.heading}" in ${params.path}${diff ? ' ' + diff : ''}`);
     }),
   },
 
@@ -593,8 +636,11 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     description: 'Replace the content of a Markdown section identified by its heading. The section spans from the heading to the next heading of equal or higher level. If heading matches fail, use edit_lines instead.',
     parameters: UpdateSectionParams,
     execute: safeExecute(async (_id, params: Static<typeof UpdateSectionParams>) => {
+      const before = safeReadContent(params.path);
       updateSection(params.path, params.heading, params.content);
-      return textResult(`Section "${params.heading}" updated in ${params.path}`);
+      const after = safeReadContent(params.path);
+      const diff = buildDiffSummary(before, after);
+      return textResult(`Section "${params.heading}" updated in ${params.path}${diff ? ' ' + diff : ''}`);
     }),
   },
 
@@ -607,12 +653,13 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
       const { path: fp, start_line, end_line, content } = params;
       const start = Math.max(0, start_line - 1);
       const end = Math.max(0, end_line - 1);
-      
+      const before = safeReadContent(fp);
       const mindRoot = getMindRoot();
-      // Import the core function dynamically or it should be added to lib/fs.ts
       const { updateLines } = await import('@/lib/core');
       updateLines(mindRoot, fp, start, end, content.split('\n'));
-      return textResult(`Lines ${start_line}-${end_line} replaced in ${fp}`);
+      const after = safeReadContent(fp);
+      const diff = buildDiffSummary(before, after);
+      return textResult(`Lines ${start_line}-${end_line} replaced in ${fp}${diff ? ' ' + diff : ''}`);
     }),
   },
 

package/app/lib/core/export.ts

@@ -0,0 +1,116 @@
+import fs from 'fs';
+import path from 'path';
+import { remark } from 'remark';
+import remarkGfm from 'remark-gfm';
+import remarkHtml from 'remark-html';
+
+/** Convert wiki-links [[target]] → relative HTML links */
+export function convertWikiLinks(content: string, _currentPath: string): string {
+  return content.replace(/\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]/g, (_match, target: string, display?: string) => {
+    const label = display ?? target;
+    const href = target.replace(/\s+/g, '%20');
+    return `<a href="${href}.html">${label}</a>`;
+  });
+}
+
+/** Convert markdown to a complete standalone HTML document */
+export async function markdownToHTML(content: string, title: string, currentPath = ''): Promise<string> {
+  // Convert wiki-links first
+  const processed = convertWikiLinks(content, currentPath);
+
+  const result = await remark()
+    .use(remarkGfm)
+    .use(remarkHtml, { sanitize: false })
+    .process(processed);
+
+  const body = String(result);
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+  <style>
+    :root { color-scheme: light dark; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      max-width: 720px;
+      margin: 2rem auto;
+      padding: 0 1.5rem;
+      line-height: 1.7;
+      color: #1a1a1a;
+      background: #fff;
+    }
+    @media (prefers-color-scheme: dark) {
+      body { color: #e0e0e0; background: #1a1a1a; }
+      a { color: #6eb5ff; }
+      code { background: #2a2a2a; }
+      pre { background: #2a2a2a; }
+      blockquote { border-color: #444; }
+      table, th, td { border-color: #444; }
+    }
+    h1 { font-size: 1.8rem; font-weight: 700; margin: 2rem 0 1rem; border-bottom: 1px solid #eee; padding-bottom: 0.3rem; }
+    h2 { font-size: 1.4rem; font-weight: 600; margin: 1.5rem 0 0.8rem; }
+    h3 { font-size: 1.15rem; font-weight: 600; margin: 1.2rem 0 0.5rem; }
+    a { color: #0066cc; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+    code { font-family: 'SF Mono', Menlo, monospace; font-size: 0.875em; background: #f5f5f5; padding: 0.15em 0.4em; border-radius: 3px; }
+    pre { background: #f5f5f5; padding: 1rem; border-radius: 6px; overflow-x: auto; }
+    pre code { background: none; padding: 0; }
+    blockquote { margin: 1rem 0; padding: 0.5rem 1rem; border-left: 3px solid #ddd; color: #666; }
+    table { border-collapse: collapse; width: 100%; margin: 1rem 0; }
+    th, td { border: 1px solid #ddd; padding: 0.5rem 0.75rem; text-align: left; }
+    th { background: #f8f8f8; font-weight: 600; }
+    img { max-width: 100%; height: auto; border-radius: 4px; }
+    hr { border: none; border-top: 1px solid #eee; margin: 2rem 0; }
+    ul, ol { padding-left: 1.5rem; }
+    li { margin: 0.25rem 0; }
+    .task-list-item { list-style: none; margin-left: -1.5rem; }
+    .task-list-item input { margin-right: 0.5rem; }
+    @media print {
+      body { max-width: 100%; margin: 0; padding: 1rem; }
+      a { color: inherit; text-decoration: underline; }
+    }
+  </style>
+</head>
+<body>
+${body}
+<footer style="margin-top:3rem;padding-top:1rem;border-top:1px solid #eee;font-size:0.75rem;color:#999;">
+  Exported from MindOS
+</footer>
+</body>
+</html>`;
+}
+
+function escapeHtml(str: string): string {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+/** Collect all exportable files in a directory tree */
+export function collectExportFiles(mindRoot: string, dirPath: string): { relativePath: string; content: string }[] {
+  const fullDir = path.join(mindRoot, dirPath);
+  if (!fs.existsSync(fullDir) || !fs.statSync(fullDir).isDirectory()) return [];
+
+  const results: { relativePath: string; content: string }[] = [];
+  const SKIP = new Set(['INSTRUCTION.md', '.DS_Store']);
+
+  function walk(dir: string, prefix: string) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') || SKIP.has(entry.name)) continue;
+      const fullPath = path.join(dir, entry.name);
+      const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(fullPath, relPath);
+      } else if (entry.name.endsWith('.md') || entry.name.endsWith('.csv')) {
+        try {
+          results.push({ relativePath: relPath, content: fs.readFileSync(fullPath, 'utf-8') });
+        } catch { /* skip unreadable */ }
+      }
+    }
+  }
+
+  walk(fullDir, '');
+  return results;
+}

package/app/lib/core/trash.ts

@@ -0,0 +1,241 @@
+import fs from 'fs';
+import path from 'path';
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface TrashMeta {
+  id: string;
+  originalPath: string;
+  deletedAt: string;
+  expiresAt: string;
+  fileName: string;
+  isDirectory: boolean;
+}
+
+const TRASH_DIR = '.trash';
+const META_DIR = '.trash-meta';
+const EXPIRY_DAYS = 30;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function siblingDir(mindRoot: string, name: string): string {
+  return path.join(path.dirname(mindRoot), name);
+}
+
+function trashRoot(mindRoot: string): string {
+  return siblingDir(mindRoot, TRASH_DIR);
+}
+
+function metaRoot(mindRoot: string): string {
+  return siblingDir(mindRoot, META_DIR);
+}
+
+function ensureDirs(mindRoot: string): void {
+  fs.mkdirSync(trashRoot(mindRoot), { recursive: true });
+  fs.mkdirSync(metaRoot(mindRoot), { recursive: true });
+}
+
+/** Sanitize filename for use as trash ID — strip all unsafe characters */
+function generateId(fileName: string): string {
+  const safe = fileName.replace(/[^a-zA-Z0-9._\-\u4e00-\u9fff]/g, '_');
+  return `${Date.now()}_${safe}`;
+}
+
+function writeMeta(mindRoot: string, meta: TrashMeta): void {
+  const metaPath = path.join(metaRoot(mindRoot), `${meta.id}.json`);
+  fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
+}
+
+function readMeta(mindRoot: string, id: string): TrashMeta | null {
+  const metaPath = path.join(metaRoot(mindRoot), `${id}.json`);
+  if (!fs.existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function deleteMeta(mindRoot: string, id: string): void {
+  const metaPath = path.join(metaRoot(mindRoot), `${id}.json`);
+  try { fs.unlinkSync(metaPath); } catch { /* already gone */ }
+}
+
+/**
+ * Move a file or directory safely, handling cross-filesystem (EXDEV) errors.
+ * Tries atomic rename first, falls back to copy+delete.
+ */
+function safeMove(src: string, dest: string, isDir: boolean): void {
+  if (isDir) {
+    // Directories always use copy+delete (rename doesn't work for dirs across fs)
+    fs.cpSync(src, dest, { recursive: true });
+    fs.rmSync(src, { recursive: true, force: true });
+  } else {
+    try {
+      fs.renameSync(src, dest);
+    } catch (err: unknown) {
+      const e = err as NodeJS.ErrnoException;
+      if (e.code === 'EXDEV') {
+        // Cross-device: fallback to copy+delete
+        fs.copyFileSync(src, dest);
+        fs.unlinkSync(src);
+      } else {
+        throw err;
+      }
+    }
+  }
+}
+
+// ─── Core Operations ─────────────────────────────────────────────────────────
+
+export function moveToTrash(mindRoot: string, filePath: string): TrashMeta {
+  ensureDirs(mindRoot);
+  const src = path.join(mindRoot, filePath);
+  if (!fs.existsSync(src)) throw new Error(`File not found: ${filePath}`);
+
+  const isDir = fs.statSync(src).isDirectory();
+  const fileName = path.basename(filePath);
+  const id = generateId(fileName);
+  const dest = path.join(trashRoot(mindRoot), id);
+
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  safeMove(src, dest, isDir);
+
+  const now = new Date();
+  const meta: TrashMeta = {
+    id,
+    originalPath: filePath,
+    deletedAt: now.toISOString(),
+    expiresAt: new Date(now.getTime() + EXPIRY_DAYS * 86400000).toISOString(),
+    fileName,
+    isDirectory: isDir,
+  };
+  writeMeta(mindRoot, meta);
+  return meta;
+}
+
+export function restoreFromTrash(mindRoot: string, trashId: string, overwrite = false): { restoredPath: string } {
+  const meta = readMeta(mindRoot, trashId);
+  if (!meta) throw new Error('Item not found in trash');
+
+  const trashPath = path.join(trashRoot(mindRoot), trashId);
+  if (!fs.existsSync(trashPath)) throw new Error('Trash file missing from disk');
+
+  const dest = path.join(mindRoot, meta.originalPath);
+
+  // Check for conflicts
+  if (fs.existsSync(dest) && !overwrite) {
+    throw Object.assign(new Error('Restore conflict: file exists at original location'), { code: 'RESTORE_CONFLICT' });
+  }
+
+  // Ensure parent directory exists
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+
+  if (meta.isDirectory) {
+    if (overwrite && fs.existsSync(dest)) {
+      fs.rmSync(dest, { recursive: true, force: true });
+    }
+  } else {
+    if (overwrite && fs.existsSync(dest)) {
+      fs.unlinkSync(dest);
+    }
+  }
+
+  safeMove(trashPath, dest, meta.isDirectory);
+  deleteMeta(mindRoot, trashId);
+  return { restoredPath: meta.originalPath };
+}
+
+export function restoreAsCopy(mindRoot: string, trashId: string): { restoredPath: string } {
+  const meta = readMeta(mindRoot, trashId);
+  if (!meta) throw new Error('Item not found in trash');
+
+  const trashPath = path.join(trashRoot(mindRoot), trashId);
+  if (!fs.existsSync(trashPath)) throw new Error('Trash file missing from disk');
+
+  // Generate a unique copy name
+  const dir = path.dirname(meta.originalPath);
+  const ext = path.extname(meta.fileName);
+  const base = path.basename(meta.fileName, ext);
+  let copyPath = path.join(dir, `${base} (copy)${ext}`);
+  let counter = 2;
+  while (fs.existsSync(path.join(mindRoot, copyPath))) {
+    copyPath = path.join(dir, `${base} (copy ${counter})${ext}`);
+    counter++;
+  }
+
+  const dest = path.join(mindRoot, copyPath);
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  safeMove(trashPath, dest, meta.isDirectory);
+
+  deleteMeta(mindRoot, trashId);
+  return { restoredPath: copyPath };
+}
+
+export function permanentlyDelete(mindRoot: string, trashId: string): void {
+  const trashPath = path.join(trashRoot(mindRoot), trashId);
+  try {
+    if (fs.existsSync(trashPath)) {
+      const stat = fs.statSync(trashPath);
+      if (stat.isDirectory()) {
+        fs.rmSync(trashPath, { recursive: true, force: true });
+      } else {
+        fs.unlinkSync(trashPath);
+      }
+    }
+  } catch { /* file already gone */ }
+  deleteMeta(mindRoot, trashId);
+}
+
+export function listTrash(mindRoot: string): TrashMeta[] {
+  ensureDirs(mindRoot);
+  const metaDir = metaRoot(mindRoot);
+  let files: string[];
+  try {
+    files = fs.readdirSync(metaDir).filter(f => f.endsWith('.json'));
+  } catch {
+    return [];
+  }
+  const items: TrashMeta[] = [];
+
+  for (const file of files) {
+    try {
+      const meta = JSON.parse(fs.readFileSync(path.join(metaDir, file), 'utf-8')) as TrashMeta;
+      // Verify the trash file still exists on disk
+      const trashPath = path.join(trashRoot(mindRoot), meta.id);
+      if (fs.existsSync(trashPath)) {
+        items.push(meta);
+      } else {
+        // Clean up orphaned metadata
+        try { fs.unlinkSync(path.join(metaDir, file)); } catch { /* race ok */ }
+      }
+    } catch {
+      // Skip corrupt metadata files
+    }
+  }
+
+  // Sort by deletion time, newest first
+  items.sort((a, b) => new Date(b.deletedAt).getTime() - new Date(a.deletedAt).getTime());
+  return items;
+}
+
+export function emptyTrash(mindRoot: string): number {
+  const items = listTrash(mindRoot);
+  for (const item of items) {
+    permanentlyDelete(mindRoot, item.id);
+  }
+  return items.length;
+}
+
+export function purgeExpired(mindRoot: string): number {
+  const items = listTrash(mindRoot);
+  const now = Date.now();
+  let count = 0;
+  for (const item of items) {
+    if (new Date(item.expiresAt).getTime() <= now) {
+      permanentlyDelete(mindRoot, item.id);
+      count++;
+    }
+  }
+  return count;
+}

package/app/lib/fs.ts

@@ -601,6 +601,53 @@ export type { BacklinkEntry } from './core/types';
 export type { MindSpaceSummary } from './core';
 export type { ContentChangeEvent, ContentChangeInput, ContentChangeSummary, ContentChangeSource } from './core';
 
+// ─── Public API: Trash (delegated to @mindos/core/trash) ────────────────────
+
+import {
+  moveToTrash as coreMoveToTrash,
+  restoreFromTrash as coreRestoreFromTrash,
+  restoreAsCopy as coreRestoreAsCopy,
+  permanentlyDelete as corePermanentlyDelete,
+  listTrash as coreListTrash,
+  emptyTrash as coreEmptyTrash,
+  purgeExpired as corePurgeExpired,
+} from './core/trash';
+export type { TrashMeta } from './core/trash';
+
+export function moveToTrashFile(filePath: string) {
+  const result = coreMoveToTrash(getMindRoot(), filePath);
+  invalidateCache();
+  return result;
+}
+
+export function restoreFromTrash(trashId: string, overwrite = false) {
+  const result = coreRestoreFromTrash(getMindRoot(), trashId, overwrite);
+  invalidateCache();
+  return result;
+}
+
+export function restoreAsCopy(trashId: string) {
+  const result = coreRestoreAsCopy(getMindRoot(), trashId);
+  invalidateCache();
+  return result;
+}
+
+export function permanentlyDeleteFromTrash(trashId: string) {
+  corePermanentlyDelete(getMindRoot(), trashId);
+}
+
+export function listTrash() {
+  return coreListTrash(getMindRoot());
+}
+
+export function emptyTrashAll() {
+  return coreEmptyTrash(getMindRoot());
+}
+
+export function purgeExpiredTrash() {
+  return corePurgeExpired(getMindRoot());
+}
+
 export function findBacklinks(targetPath: string): BacklinkEntry[] {
   const { allFiles } = ensureCache();
   return coreFindBacklinks(getMindRoot(), targetPath, allFiles);