@geminilight/mindos 0.6.38 → 0.6.40

package/app/app/api/acp/detect/route.ts

@@ -26,36 +26,45 @@ interface NotInstalledAgent {
   packageName?: string;
 }
 
-/* ── Server-side detection cache (5 min TTL) ──────────────────────────── */
+/* ── Server-side detection cache (30 min TTL) ─────────────────────────── */
 
-const DETECT_CACHE_TTL_MS = 5 * 60 * 1000;
+const DETECT_CACHE_TTL_MS = 30 * 60 * 1000;
 let detectCache: { data: { installed: InstalledAgent[]; notInstalled: NotInstalledAgent[] }; ts: number } | null = null;
 
 /* ── Async detection helpers ──────────────────────────────────────────── */
 
-function whichAsync(binary: string): Promise<string | null> {
-  return new Promise((resolve) => {
-    const child = exec(`which ${binary}`, { encoding: 'utf-8', timeout: 2000 }, (err, stdout) => {
-      resolve(err ? null : (stdout.trim() || null));
-    });
-    child.on('error', () => resolve(null));
-  });
-}
-
 /**
- * Batch `which` for multiple unique binaries in a single call.
- * Returns a Map<binary, path | null>.
+ * Single-shell batch detection. Runs one `which` per binary but via a
+ * combined shell script so we spawn exactly ONE child process.
+ * Output: one line per binary — either the path or empty.
  */
-async function whichBatch(binaries: string[]): Promise<Map<string, string | null>> {
+function whichBatch(binaries: string[]): Promise<Map<string, string | null>> {
   const unique = [...new Set(binaries)];
-  if (unique.length === 0) return new Map();
+  if (unique.length === 0) return Promise.resolve(new Map());
 
-  const results = await Promise.all(unique.map(async (bin) => {
-    const path = await whichAsync(bin);
-    return [bin, path] as const;
-  }));
+  // Build a shell snippet: for each binary, print path or empty line
+  // e.g. `which gemini 2>/dev/null || echo ""; which claude 2>/dev/null || echo ""`
+  const script = unique
+    .map(bin => `which ${bin} 2>/dev/null || echo ""`)
+    .join('; ');
 
-  return new Map(results);
+  return new Promise((resolve) => {
+    exec(script, { encoding: 'utf-8', timeout: 3000 }, (err, stdout) => {
+      const map = new Map<string, string | null>();
+      if (err) {
+        // On total failure, mark all as not found
+        for (const bin of unique) map.set(bin, null);
+        resolve(map);
+        return;
+      }
+      const lines = stdout.split('\n');
+      for (let i = 0; i < unique.length; i++) {
+        const line = (lines[i] ?? '').trim();
+        map.set(unique[i], line || null);
+      }
+      resolve(map);
+    });
+  });
 }
 
 /* ── Route handler ─────────────────────────────────────────────────────── */

package/app/app/api/agent-activity/route.ts

@@ -10,7 +10,7 @@ import { effectiveSopRoot } from '@/lib/settings';
  */
 export async function GET(req: NextRequest) {
   const limitParam = req.nextUrl.searchParams.get('limit');
-  const limit = Math.max(1, Math.min(Number(limitParam) || 10, 50));
+  const limit = Math.max(1, Math.min(Number(limitParam) || 10, 500));
 
   const root = effectiveSopRoot();
   const events = listAgentAuditEvents(root, limit);

package/app/app/api/ask/route.ts

@@ -17,10 +17,12 @@ import {
 import { NextRequest, NextResponse } from 'next/server';
 import fs from 'fs';
 import path from 'path';
-import { getFileContent, getMindRoot } from '@/lib/fs';
+import { getFileContent, getMindRoot, collectAllFiles } from '@/lib/fs';
 import { getModelConfig, hasImages } from '@/lib/agent/model';
-import { getRequestScopedTools, getOrganizeTools, WRITE_TOOLS, truncate } from '@/lib/agent/tools';
-import { AGENT_SYSTEM_PROMPT, ORGANIZE_SYSTEM_PROMPT } from '@/lib/agent/prompt';
+import { isProviderId, type ProviderId } from '@/lib/agent/providers';
+import { getRequestScopedTools, getOrganizeTools, getChatTools, WRITE_TOOLS, truncate } from '@/lib/agent/tools';
+import { AGENT_SYSTEM_PROMPT, ORGANIZE_SYSTEM_PROMPT, CHAT_SYSTEM_PROMPT } from '@/lib/agent/prompt';
+import type { AskModeApi } from '@/lib/types';
 import { toAgentMessages } from '@/lib/agent/to-agent-messages';
 import { logAgentOp } from '@/lib/agent/log';
 import { readSettings } from '@/lib/settings';
@@ -32,6 +34,26 @@ import { createSession, promptStream, closeSession } from '@/lib/acp/session';
 import type { AcpSessionUpdate } from '@/lib/acp/types';
 import type { Message as FrontendMessage } from '@/lib/types';
 
+const MAX_DIR_FILES = 30;
+
+/** Expand attachedFiles entries: directory paths (trailing /) become individual file paths. */
+function expandAttachedFiles(raw: string[]): string[] {
+  const result: string[] = [];
+  const allFiles = collectAllFiles();
+  for (const entry of raw) {
+    if (entry.endsWith('/')) {
+      const prefix = entry;
+      let count = 0;
+      for (const f of allFiles) {
+        if (f.startsWith(prefix) && ++count <= MAX_DIR_FILES) result.push(f);
+      }
+    } else {
+      result.push(entry);
+    }
+  }
+  return result;
+}
+
 /** Safe JSON parse — returns {} on invalid input */
 function safeParseJson(raw: string | undefined): Record<string, unknown> {
   if (!raw) return {};
@@ -294,6 +316,7 @@ function toPiCustomToolDefinitions(tools: AgentTool<any>[]): ToolDefinition<any,
           params: args,
           result: outputText.startsWith('Error:') ? 'error' : 'ok',
           message: outputText.slice(0, 200),
+          agentName: 'MindOS Ask',
         });
       } catch {
         // logging must never kill the stream
@@ -315,10 +338,12 @@ export async function POST(req: NextRequest) {
     attachedFiles?: string[];
     uploadedFiles?: Array<{ name: string; content: string }>;
     maxSteps?: number;
-    /** 'organize' = lean prompt for file import organize; default = full prompt */
-    mode?: 'organize' | 'default';
+    /** Ask mode: 'chat' = read-only tools; 'agent' = full tools; 'organize' = lean import mode */
+    mode?: AskModeApi;
     /** ACP agent selection: if present, route to ACP instead of MindOS */
     selectedAcpAgent?: { id: string; name: string } | null;
+    /** Per-request provider override from the chat panel capsule */
+    providerOverride?: string;
   };
   try {
     body = await req.json();
@@ -326,20 +351,24 @@ export async function POST(req: NextRequest) {
     return apiError(ErrorCodes.INVALID_REQUEST, 'Invalid JSON body', 400);
   }
 
-  const { messages, currentFile, attachedFiles, uploadedFiles, selectedAcpAgent } = body;
-  const isOrganizeMode = body.mode === 'organize';
+  const { messages, currentFile, attachedFiles: rawAttached, uploadedFiles, selectedAcpAgent } = body;
+  const attachedFiles = Array.isArray(rawAttached) ? expandAttachedFiles(rawAttached) : rawAttached;
+  const askMode: AskModeApi = body.mode === 'organize' ? 'organize'
+    : body.mode === 'chat' ? 'chat'
+    : 'agent';
 
   // Read agent config from settings
   const serverSettings = readSettings();
   const agentConfig = serverSettings.agent ?? {};
+  const defaultMaxSteps = askMode === 'chat' ? 8 : (agentConfig.maxSteps ?? 20);
   const stepLimit = Number.isFinite(body.maxSteps)
     ? Math.min(30, Math.max(1, Number(body.maxSteps)))
-    : Math.min(30, Math.max(1, agentConfig.maxSteps ?? 20));
+    : Math.min(30, Math.max(1, defaultMaxSteps));
   const enableThinking = agentConfig.enableThinking ?? false;
   const thinkingBudget = agentConfig.thinkingBudget ?? 5000;
   const contextStrategy = agentConfig.contextStrategy ?? 'auto';
 
-  // Uploaded files — shared by both modes
+  // Uploaded files — shared by all modes
   const uploadedParts: string[] = [];
   if (Array.isArray(uploadedFiles) && uploadedFiles.length > 0) {
     for (const f of uploadedFiles.slice(0, 8)) {
@@ -349,11 +378,11 @@ export async function POST(req: NextRequest) {
   }
 
   // ---------------------------------------------------------------------------
-  // Build system prompt — lean path for organize mode, full path otherwise
+  // Build system prompt — three-way split by askMode
   // ---------------------------------------------------------------------------
   let systemPrompt: string;
 
-  if (isOrganizeMode) {
+  if (askMode === 'organize') {
     // Organize mode: minimal prompt — only KB structure + uploaded files
     const promptParts: string[] = [ORGANIZE_SYSTEM_PROMPT];
 
@@ -373,9 +402,57 @@ export async function POST(req: NextRequest) {
       );
     }
 
+    systemPrompt = promptParts.join('\n\n');
+  } else if (askMode === 'chat') {
+    // Chat mode: lean prompt with read-only KB access.
+    // Skips: SKILL.md, bootstrap INSTRUCTION/CONFIG, write-supplement, target dir context.
+    // Keeps: KB structure (README.md), time, current/attached files, uploaded files.
+    const promptParts: string[] = [CHAT_SYSTEM_PROMPT];
+
+    promptParts.push(`---\n\nmind_root=${getMindRoot()}`);
+
+    const bootstrapIndex = readKnowledgeFile('README.md');
+    if (bootstrapIndex.ok && bootstrapIndex.content.trim().length > 10) {
+      promptParts.push(`---\n\n## Knowledge Base Structure\n\n${bootstrapIndex.content}`);
+    }
+
+    const now = new Date();
+    promptParts.push(`---\n\n## Current Time Context\n- Current UTC Time: ${now.toISOString()}\n- System Local Time: ${new Intl.DateTimeFormat('en-US', { dateStyle: 'full', timeStyle: 'long' }).format(now)}`);
+
+    const contextParts: string[] = [];
+    const seen = new Set<string>();
+    if (Array.isArray(attachedFiles) && attachedFiles.length > 0) {
+      for (const filePath of attachedFiles!) {
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        try {
+          const content = truncate(getFileContent(filePath));
+          contextParts.push(`## Attached: ${filePath}\n\n${content}`);
+        } catch { /* ignore missing files */ }
+      }
+    }
+    if (currentFile && !seen.has(currentFile)) {
+      seen.add(currentFile);
+      try {
+        const content = truncate(getFileContent(currentFile));
+        contextParts.push(`## Current file: ${currentFile}\n\n${content}`);
+      } catch { /* ignore */ }
+    }
+    if (contextParts.length > 0) {
+      promptParts.push(`---\n\nThe user is currently viewing these files:\n\n${contextParts.join('\n\n---\n\n')}`);
+    }
+
+    if (uploadedParts.length > 0) {
+      promptParts.push(
+        `---\n\n## ⚠️ USER-UPLOADED FILES\n\n` +
+        `Their FULL CONTENT is below. Use this directly — do NOT call read tools on them.\n\n` +
+        uploadedParts.join('\n\n---\n\n'),
+      );
+    }
+
     systemPrompt = promptParts.join('\n\n');
   } else {
-    // Full mode: original prompt assembly
+    // Agent mode: full prompt assembly
     // Auto-load skill + bootstrap context for each request.
     const isZh = serverSettings.disabledSkills?.includes('mindos') ?? false;
     const skillDirName = isZh ? 'mindos-zh' : 'mindos';
@@ -383,22 +460,24 @@ export async function POST(req: NextRequest) {
       ? path.join(process.env.MINDOS_PROJECT_ROOT, 'app')
       : process.cwd();
     const skillPath = path.join(appDir, `data/skills/${skillDirName}/SKILL.md`);
+    const skillWritePath = path.join(appDir, `data/skills/${skillDirName}/references/write-supplement.md`);
     const skill = readAbsoluteFile(skillPath);
+    const skillWrite = readAbsoluteFile(skillWritePath);
+
+    console.log(`[ask] SKILL skill=${skill.ok}, write-supplement=${skillWrite.ok}`);
 
-    const userSkillRules = readKnowledgeFile('user-skill-rules.md');
+    const userSkillRules = readKnowledgeFile('.mindos/user-preferences.md');
 
     const targetDir = dirnameOf(currentFile);
     const bootstrap = {
       instruction: readKnowledgeFile('INSTRUCTION.md'),
       config_json: readKnowledgeFile('CONFIG.json'),
       // Lazy-loaded: only read if the file exists and has content.
-      // README.md and CONFIG.md are often empty/boilerplate and waste tokens.
+      // README.md is often empty/boilerplate and wastes tokens.
       index: null as ReturnType<typeof readKnowledgeFile> | null,
-      config_md: null as ReturnType<typeof readKnowledgeFile> | null,
       target_readme: null as ReturnType<typeof readKnowledgeFile> | null,
       target_instruction: null as ReturnType<typeof readKnowledgeFile> | null,
       target_config_json: null as ReturnType<typeof readKnowledgeFile> | null,
-      target_config_md: null as ReturnType<typeof readKnowledgeFile> | null,
     };
 
     // Only load secondary bootstrap files if they have meaningful content.
@@ -409,9 +488,6 @@ export async function POST(req: NextRequest) {
     const indexResult = readKnowledgeFile('README.md');
     if (indexResult.ok && indexResult.content.trim().length > MIN_USEFUL_CONTENT_LENGTH) bootstrap.index = indexResult;
 
-    const configMdResult = readKnowledgeFile('CONFIG.md');
-    if (configMdResult.ok && configMdResult.content.trim().length > MIN_USEFUL_CONTENT_LENGTH) bootstrap.config_md = configMdResult;
-
     if (targetDir) {
       const tr = readKnowledgeFile(`${targetDir}/README.md`);
       if (tr.ok && tr.content.trim().length > MIN_USEFUL_CONTENT_LENGTH) bootstrap.target_readme = tr;
@@ -419,35 +495,37 @@ export async function POST(req: NextRequest) {
       if (ti.ok && ti.content.trim().length > MIN_USEFUL_CONTENT_LENGTH) bootstrap.target_instruction = ti;
       const tc = readKnowledgeFile(`${targetDir}/CONFIG.json`);
       if (tc.ok && tc.content.trim().length > MIN_USEFUL_CONTENT_LENGTH) bootstrap.target_config_json = tc;
-      const tm = readKnowledgeFile(`${targetDir}/CONFIG.md`);
-      if (tm.ok && tm.content.trim().length > MIN_USEFUL_CONTENT_LENGTH) bootstrap.target_config_md = tm;
     }
 
-    // Only report failures + truncation warnings for loaded files
     const initFailures: string[] = [];
     const truncationWarnings: string[] = [];
     if (!skill.ok) initFailures.push(`skill.mindos: failed (${skill.error})`);
     if (skill.ok && skill.truncated) truncationWarnings.push('skill.mindos was truncated');
-    if (userSkillRules.ok && userSkillRules.truncated) truncationWarnings.push('user-skill-rules.md was truncated');
+    if (!skillWrite.ok) initFailures.push(`skill.mindos-write-supplement: failed (${skillWrite.error})`);
+    if (skillWrite.ok && skillWrite.truncated) truncationWarnings.push('skill.mindos-write-supplement was truncated');
+    if (userSkillRules.ok && userSkillRules.truncated) truncationWarnings.push('.mindos/user-preferences.md was truncated');
     if (!bootstrap.instruction.ok) initFailures.push(`bootstrap.instruction: failed (${bootstrap.instruction.error})`);
     if (bootstrap.instruction.ok && bootstrap.instruction.truncated) truncationWarnings.push('bootstrap.instruction was truncated');
     if (bootstrap.index?.ok && bootstrap.index.truncated) truncationWarnings.push('bootstrap.index was truncated');
     if (!bootstrap.config_json.ok) initFailures.push(`bootstrap.config_json: failed (${bootstrap.config_json.error})`);
     if (bootstrap.config_json.ok && bootstrap.config_json.truncated) truncationWarnings.push('bootstrap.config_json was truncated');
-    if (bootstrap.config_md?.ok && bootstrap.config_md.truncated) truncationWarnings.push('bootstrap.config_md was truncated');
     if (bootstrap.target_readme?.ok && bootstrap.target_readme.truncated) truncationWarnings.push('bootstrap.target_readme was truncated');
     if (bootstrap.target_instruction?.ok && bootstrap.target_instruction.truncated) truncationWarnings.push('bootstrap.target_instruction was truncated');
     if (bootstrap.target_config_json?.ok && bootstrap.target_config_json.truncated) truncationWarnings.push('bootstrap.target_config_json was truncated');
-    if (bootstrap.target_config_md?.ok && bootstrap.target_config_md.truncated) truncationWarnings.push('bootstrap.target_config_md was truncated');
 
     const initStatus = initFailures.length === 0
       ? `All initialization contexts loaded successfully. mind_root=${getMindRoot()}${targetDir ? `, target_dir=${targetDir}` : ''}${truncationWarnings.length > 0 ? ` ⚠️ ${truncationWarnings.length} files truncated` : ''}`
       : `Initialization issues:\n${initFailures.join('\n')}\nmind_root=${getMindRoot()}${targetDir ? `, target_dir=${targetDir}` : ''}${truncationWarnings.length > 0 ? `\n⚠️ Warnings:\n${truncationWarnings.join('\n')}` : ''}`;
 
     const initContextBlocks: string[] = [];
-    if (skill.ok) initContextBlocks.push(`## mindos_skill_md\n\n${skill.content}`);
+    const skillParts: string[] = [];
+    if (skill.ok) skillParts.push(skill.content);
+    if (skillWrite.ok) skillParts.push(skillWrite.content);
+    if (skillParts.length > 0) {
+      initContextBlocks.push(`## mindos_skill_md\n\n${skillParts.join('\n\n---\n\n')}`);
+    }
     if (userSkillRules.ok && !userSkillRules.truncated && userSkillRules.content.trim()) {
-      initContextBlocks.push(`## user_skill_rules\n\nUser personalization rules (user-skill-rules.md):\n\n${userSkillRules.content}`);
+      initContextBlocks.push(`## user_skill_rules\n\nUser personalization preferences (.mindos/user-preferences.md):\n\n${userSkillRules.content}`);
     }
     if (bootstrap.instruction.ok) initContextBlocks.push(`## bootstrap_instruction\n\n${bootstrap.instruction.content}`);
     if (bootstrap.index?.ok) initContextBlocks.push(`## bootstrap_index\n\n${bootstrap.index.content}`);
@@ -463,11 +541,9 @@ export async function POST(req: NextRequest) {
       } catch { /* keep original if parse fails */ }
       initContextBlocks.push(`## bootstrap_config_json\n\n${configContent}`);
     }
-    if (bootstrap.config_md?.ok) initContextBlocks.push(`## bootstrap_config_md\n\n${bootstrap.config_md.content}`);
     if (bootstrap.target_readme?.ok) initContextBlocks.push(`## bootstrap_target_readme\n\n${bootstrap.target_readme.content}`);
     if (bootstrap.target_instruction?.ok) initContextBlocks.push(`## bootstrap_target_instruction\n\n${bootstrap.target_instruction.content}`);
     if (bootstrap.target_config_json?.ok) initContextBlocks.push(`## bootstrap_target_config_json\n\n${bootstrap.target_config_json.content}`);
-    if (bootstrap.target_config_md?.ok) initContextBlocks.push(`## bootstrap_target_config_md\n\n${bootstrap.target_config_md.content}`);
 
     // Build initial context from attached/current files
     const contextParts: string[] = [];
@@ -531,7 +607,13 @@ export async function POST(req: NextRequest) {
   }
 
   try {
-    const { model, modelName, apiKey, provider } = getModelConfig({ hasImages: hasImages(messages) });
+    const provOverride = body.providerOverride && isProviderId(body.providerOverride)
+      ? body.providerOverride as ProviderId
+      : undefined;
+    const { model, modelName, apiKey, provider } = getModelConfig({
+      provider: provOverride,
+      hasImages: hasImages(messages),
+    });
 
     // Convert frontend messages to AgentMessage[]
     const agentMessages = toAgentMessages(messages);
@@ -550,7 +632,9 @@ export async function POST(req: NextRequest) {
     // Capture API key for this request — safe since each POST creates a new Agent instance.
     const requestApiKey = apiKey;
     const projectRoot = process.env.MINDOS_PROJECT_ROOT || path.resolve(process.cwd(), '..');
-    const requestTools = isOrganizeMode ? getOrganizeTools() : await getRequestScopedTools();
+    const requestTools = askMode === 'organize' ? getOrganizeTools()
+      : askMode === 'chat' ? getChatTools()
+      : await getRequestScopedTools();
     const customTools = toPiCustomToolDefinitions(requestTools);
 
     const authStorage = AuthStorage.create();

package/app/app/api/ask-sessions/route.ts

@@ -11,6 +11,7 @@ interface Message {
 
 interface ChatSession {
   id: string;
+  title?: string;
   currentFile?: string;
   createdAt: number;
   updatedAt: number;

package/app/app/api/bootstrap/route.ts

@@ -20,8 +20,7 @@ export async function GET(req: NextRequest) {
       instruction: tryRead('INSTRUCTION.md'),
       index: tryRead('README.md'),
       config_json: tryRead('CONFIG.json'),
-      config_md: tryRead('CONFIG.md'),
-      user_skill_rules: tryRead('user-skill-rules.md'),
+      user_skill_rules: tryRead('.mindos/user-preferences.md'),
     };
 
     if (targetDir) {
@@ -32,7 +31,6 @@ export async function GET(req: NextRequest) {
       result.target_readme = tryRead(path.join(targetDir, 'README.md'));
       result.target_instruction = tryRead(path.join(targetDir, 'INSTRUCTION.md'));
       result.target_config_json = tryRead(path.join(targetDir, 'CONFIG.json'));
-      result.target_config_md = tryRead(path.join(targetDir, 'CONFIG.md'));
     }
 
     return NextResponse.json(result);

package/app/app/api/file/route.ts

@@ -6,6 +6,7 @@ import { revalidatePath } from 'next/cache';
 import { resolveSafe } from '@/lib/core/security';
 import { sanitizeFileName, convertToMarkdown } from '@/lib/core/file-convert';
 import { effectiveSopRoot } from '@/lib/settings';
+import { SYSTEM_FILES, UNDELETABLE_FILES } from '@/lib/types';
 import {
   getFileContent,
   saveFileContent,
@@ -16,7 +17,7 @@ import {
   updateLines,
   insertAfterHeading,
   updateSection,
-  deleteFile,
+  moveToTrashFile,
   renameFile,
   renameSpace,
   moveFile,
@@ -33,6 +34,18 @@ function err(msg: string, status = 400) {
   return NextResponse.json({ error: msg }, { status });
 }
 
+/** Returns true if the path targets a root-level system file (INSTRUCTION.md, CONFIG.json, etc.). */
+function isSystemFile(filePath: string): boolean {
+  const basename = path.posix.basename(filePath);
+  return !filePath.includes('/') && SYSTEM_FILES.has(basename);
+}
+
+/** Root-level files visible to users but protected from deletion (e.g. TODO.md). */
+function isUndeletable(filePath: string): boolean {
+  const basename = path.posix.basename(filePath);
+  return !filePath.includes('/') && UNDELETABLE_FILES.has(basename);
+}
+
 function safeRead(filePath: string): string {
   try {
     return getFileContent(filePath);
@@ -46,9 +59,17 @@ function sourceFromRequest(req: NextRequest, body: Record<string, unknown>) {
   if (bodySource === 'agent' || bodySource === 'user' || bodySource === 'system') return bodySource;
   const headerSource = req.headers.get('x-mindos-source');
   if (headerSource === 'agent' || headerSource === 'user' || headerSource === 'system') return headerSource;
+  // If request has x-mindos-agent header, it's from an agent
+  if (req.headers.get('x-mindos-agent')) return 'agent' as const;
   return 'user' as const;
 }
 
+/** Extract agent name from request (MCP client identity, e.g. "claude-code"). */
+function agentNameFromRequest(req: NextRequest): string | undefined {
+  const name = req.headers.get('x-mindos-agent');
+  return name && name.trim() ? name.trim() : undefined;
+}
+
 // GET /api/file?path=foo.md&op=read_file|read_lines | GET ?op=list_spaces (no path)
 export async function GET(req: NextRequest) {
   const filePath = req.nextUrl.searchParams.get('path');
@@ -116,6 +137,12 @@ export async function POST(req: NextRequest) {
   if (!op || typeof op !== 'string') return err('missing op');
   if (!filePath || typeof filePath !== 'string') return err('missing path');
 
+  // Block agent writes to root-level system files (INSTRUCTION.md, CONFIG.json, etc.)
+  const source = sourceFromRequest(req, body);
+  if (source === 'agent' && isSystemFile(filePath)) {
+    return err(`System file "${filePath}" is protected and cannot be modified by agents`, 403);
+  }
+
   try {
     let resp: NextResponse;
     let changeEvent:
@@ -243,16 +270,19 @@ export async function POST(req: NextRequest) {
       }
 
       case 'delete_file': {
+        if (isUndeletable(filePath)) {
+          return err(`"${filePath}" is a protected file and cannot be deleted`, 403);
+        }
         const before = safeRead(filePath);
-        deleteFile(filePath);
+        const trashMeta = moveToTrashFile(filePath);
         changeEvent = {
           op,
           path: filePath,
-          summary: 'Deleted file',
+          summary: 'Moved to trash',
           before,
           after: '',
         };
-        resp = NextResponse.json({ ok: true });
+        resp = NextResponse.json({ ok: true, trashId: trashMeta.id });
         break;
       }
 

package/app/app/api/inbox/route.ts

@@ -0,0 +1,61 @@
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { revalidatePath } from 'next/cache';
+import { effectiveSopRoot } from '@/lib/settings';
+import { listInboxFiles, saveToInbox } from '@/lib/core/inbox';
+import { invalidateCache } from '@/lib/fs';
+
+export async function GET() {
+  const mindRoot = effectiveSopRoot().trim();
+  if (!mindRoot) {
+    return NextResponse.json({ error: 'MIND_ROOT is not configured' }, { status: 400 });
+  }
+
+  try {
+    const files = listInboxFiles(mindRoot);
+    return NextResponse.json({ files });
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 },
+    );
+  }
+}
+
+export async function POST(req: NextRequest) {
+  const mindRoot = effectiveSopRoot().trim();
+  if (!mindRoot) {
+    return NextResponse.json({ error: 'MIND_ROOT is not configured' }, { status: 400 });
+  }
+
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  if (!body || typeof body !== 'object' || !Array.isArray((body as { files?: unknown }).files)) {
+    return NextResponse.json({ error: 'Request body must contain a files array' }, { status: 400 });
+  }
+
+  const { files } = body as { files: Array<{ name: string; content: string; encoding?: 'text' | 'base64' }> };
+
+  try {
+    const result = saveToInbox(mindRoot, files);
+
+    if (result.saved.length > 0) {
+      invalidateCache();
+      try { revalidatePath('/', 'layout'); } catch { /* test env */ }
+    }
+
+    return NextResponse.json(result);
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 },
+    );
+  }
+}