@geminilight/mindos 0.6.38 → 0.6.40

package/mcp/package.json

@@ -10,12 +10,12 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.0",
-    "tsx": "^4.19.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/node": "^22",
     "esbuild": "^0.25.0",
+    "tsx": "^4.19.0",
     "typescript": "^5"
   }
 }

package/mcp/src/index.ts

@@ -30,31 +30,33 @@ const MCP_PORT       = parseInt(process.env.MCP_PORT ?? "8781", 10);
 const MCP_ENDPOINT   = process.env.MCP_ENDPOINT    ?? "/mcp";
 const CHARACTER_LIMIT = 25_000;
 
-function headers(): Record<string, string> {
+function headers(agentName?: string): Record<string, string> {
   const h: Record<string, string> = { "Content-Type": "application/json" };
   if (AUTH_TOKEN) h["Authorization"] = `Bearer ${AUTH_TOKEN}`;
+  // Sanitize: strip control chars, limit to 100 chars
+  if (agentName) h["x-mindos-agent"] = agentName.replace(/[\x00-\x1f]/g, '').slice(0, 100);
   return h;
 }
 
 // ─── HTTP helpers ────────────────────────────────────────────────────────────
 
-async function get(path: string, params?: Record<string, string>): Promise<Record<string, unknown>> {
+async function get(path: string, params?: Record<string, string>, agentName?: string): Promise<Record<string, unknown>> {
   const url = new URL(path, BASE_URL);
   if (params) {
     for (const [k, v] of Object.entries(params)) {
       if (v !== undefined && v !== null) url.searchParams.set(k, v);
     }
   }
-  const res = await fetch(url.toString(), { headers: headers() });
+  const res = await fetch(url.toString(), { headers: headers(agentName) });
   const json = await res.json() as Record<string, unknown>;
   if (!res.ok) throw new Error((json.error as string) ?? `HTTP ${res.status}`);
   return json;
 }
 
-async function post(path: string, body: Record<string, unknown>): Promise<Record<string, unknown>> {
+async function post(path: string, body: Record<string, unknown>, agentName?: string): Promise<Record<string, unknown>> {
   const res = await fetch(new URL(path, BASE_URL).toString(), {
     method: "POST",
-    headers: headers(),
+    headers: headers(agentName),
     body: JSON.stringify(body),
   });
   const json = await res.json() as Record<string, unknown>;
@@ -77,14 +79,14 @@ function truncate(text: string, limit = CHARACTER_LIMIT): string {
 
 // ─── Agent operation logging ────────────────────────────────────────────────
 
-async function logOp(tool: string, params: Record<string, unknown>, result: 'ok' | 'error', message: string) {
+async function logOp(tool: string, params: Record<string, unknown>, result: 'ok' | 'error', message: string, agentName?: string) {
   try {
-    const entry = { ts: new Date().toISOString(), tool, params, result, message: message.slice(0, 200) };
+    const entry = { ts: new Date().toISOString(), tool, params, result, message: message.slice(0, 200), agentName: agentName || undefined };
     const line = JSON.stringify(entry) + '\n';
     // Append to .agent-log.json via the app API
     await fetch(new URL("/api/file", BASE_URL).toString(), {
       method: "POST",
-      headers: headers(),
+      headers: headers(agentName),
       body: JSON.stringify({ op: "append_to_file", path: ".agent-log.json", content: line }),
     }).catch(() => {});
   } catch {
@@ -96,6 +98,17 @@ async function logOp(tool: string, params: Record<string, unknown>, result: 'ok'
 
 function registerTools(server: McpServer) {
 
+/** Get the MCP client name for this server session (e.g. "claude-code", "cursor"). */
+function clientName(): string | undefined {
+  return server.server.getClientVersion()?.name || undefined;
+}
+
+// Session-aware wrappers that auto-inject client identity into every API call
+const _get = (path: string, params?: Record<string, string>) => get(path, params, clientName());
+const _post = (path: string, body: Record<string, unknown>) => post(path, body, clientName());
+const _logOp = (tool: string, params: Record<string, unknown>, result: 'ok' | 'error', msg: string) =>
+  logOp(tool, params, result, msg, clientName());
+
 // ── mindos_list_files ───────────────────────────────────────────────────────
 
 server.registerTool("mindos_list_files", {
@@ -107,11 +120,11 @@ server.registerTool("mindos_list_files", {
   annotations: { readOnlyHint: true },
 }, async ({ response_format }) => {
   try {
-    const json = await get("/api/files", { format: response_format });
+    const json = await _get("/api/files", { format: response_format });
     const result = typeof json.tree === "string" ? json.tree : JSON.stringify(json.tree ?? json, null, 2);
-    logOp("mindos_list_files", { response_format }, "ok", `${result.length} chars`);
+    _logOp("mindos_list_files", { response_format }, "ok", `${result.length} chars`);
     return ok(result);
-  } catch (e) { logOp("mindos_list_files", { response_format }, "error", String(e)); return error(String(e)); }
+  } catch (e) { _logOp("mindos_list_files", { response_format }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_list_spaces ──────────────────────────────────────────────────────
@@ -126,20 +139,20 @@ server.registerTool("mindos_list_spaces", {
   annotations: { readOnlyHint: true },
 }, async ({ response_format }) => {
   try {
-    const json = await get("/api/file", { op: "list_spaces" });
+    const json = await _get("/api/file", { op: "list_spaces" });
     const spaces = json.spaces as Array<{ name: string; path: string; fileCount: number; description: string }>;
     if (response_format === "json") {
-      logOp("mindos_list_spaces", { response_format }, "ok", `${spaces?.length ?? 0} spaces`);
+      _logOp("mindos_list_spaces", { response_format }, "ok", `${spaces?.length ?? 0} spaces`);
       return ok(JSON.stringify({ spaces: spaces ?? [] }, null, 2));
     }
     const lines = (spaces ?? []).map(
       (s) => `- **${s.name}** (\`${s.path}/\`) — ${s.fileCount} file(s)${s.description ? ` — ${s.description}` : ""}`,
     );
     const text = lines.length ? lines.join("\n") : "(no top-level spaces in tree)";
-    logOp("mindos_list_spaces", { response_format }, "ok", `${spaces?.length ?? 0} spaces`);
+    _logOp("mindos_list_spaces", { response_format }, "ok", `${spaces?.length ?? 0} spaces`);
     return ok(text);
   } catch (e) {
-    logOp("mindos_list_spaces", { response_format }, "error", String(e));
+    _logOp("mindos_list_spaces", { response_format }, "error", String(e));
     return error(String(e));
   }
 });
@@ -157,16 +170,16 @@ server.registerTool("mindos_read_file", {
   annotations: { readOnlyHint: true },
 }, async ({ path, offset, limit }) => {
   try {
-    const json = await get("/api/file", { path, op: "read_file" });
+    const json = await _get("/api/file", { path, op: "read_file" });
     const content = json.content as string;
     const slice = content.slice(offset, offset + limit);
     const hasMore = offset + limit < content.length;
     const header = hasMore
       ? `[Showing characters ${offset}–${offset + slice.length} of ${content.length}. Use offset=${offset + limit} for next page.]\n\n`
       : offset > 0 ? `[Showing characters ${offset}–${offset + slice.length} of ${content.length}]\n\n` : "";
-    logOp("mindos_read_file", { path }, "ok", `${content.length} chars`);
+    _logOp("mindos_read_file", { path }, "ok", `${content.length} chars`);
     return ok(header + slice);
-  } catch (e) { logOp("mindos_read_file", { path }, "error", String(e)); return error(String(e)); }
+  } catch (e) { _logOp("mindos_read_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_write_file ───────────────────────────────────────────────────────
@@ -180,10 +193,10 @@ server.registerTool("mindos_write_file", {
   }),
 }, async ({ path, content }) => {
   try {
-    await post("/api/file", { op: "save_file", path, content });
-    logOp("mindos_write_file", { path }, "ok", `Wrote ${content.length} chars`);
+    await _post("/api/file", { op: "save_file", path, content });
+    _logOp("mindos_write_file", { path }, "ok", `Wrote ${content.length} chars`);
     return ok(`Successfully wrote ${content.length} characters to "${path}"`);
-  } catch (e) { logOp("mindos_write_file", { path }, "error", String(e)); return error(String(e)); }
+  } catch (e) { _logOp("mindos_write_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_create_file ──────────────────────────────────────────────────────
@@ -197,10 +210,10 @@ server.registerTool("mindos_create_file", {
   }),
 }, async ({ path, content }) => {
   try {
-    await post("/api/file", { op: "create_file", path, content });
-    logOp("mindos_create_file", { path }, "ok", `Created ${content.length} chars`);
+    await _post("/api/file", { op: "create_file", path, content });
+    _logOp("mindos_create_file", { path }, "ok", `Created ${content.length} chars`);
     return ok(`Created "${path}" (${content.length} characters)`);
-  } catch (e) { logOp("mindos_create_file", { path }, "error", String(e)); return error(String(e)); }
+  } catch (e) { _logOp("mindos_create_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_batch_create_files ────────────────────────────────────────────────
@@ -220,7 +233,7 @@ server.registerTool("mindos_batch_create_files", {
   const errors: string[] = [];
   for (const file of files) {
     try {
-      await post("/api/file", { op: "create_file", path: file.path, content: file.content });
+      await _post("/api/file", { op: "create_file", path: file.path, content: file.content });
       created.push(file.path);
     } catch (e) {
       errors.push(`${file.path}: ${String(e)}`);
@@ -228,7 +241,7 @@ server.registerTool("mindos_batch_create_files", {
   }
   let msg = `Batch creation complete.\nCreated ${created.length} file(s): ${created.join(", ")}`;
   if (errors.length > 0) msg += `\n\nFailed to create ${errors.length} file(s):\n${errors.join("\n")}`;
-  logOp("mindos_batch_create_files", { count: files.length }, created.length === files.length ? "ok" : "error", msg.slice(0, 200));
+  _logOp("mindos_batch_create_files", { count: files.length }, created.length === files.length ? "ok" : "error", msg.slice(0, 200));
   return created.length === files.length ? ok(msg) : error(msg);
 });
 
@@ -245,7 +258,7 @@ server.registerTool("mindos_create_space", {
   }),
 }, async ({ name, description, parent_path }) => {
   try {
-    const json = await post("/api/file", {
+    const json = await _post("/api/file", {
       op: "create_space",
       path: "_",
       name,
@@ -253,10 +266,10 @@ server.registerTool("mindos_create_space", {
       parent_path,
     });
     const p = json.path as string;
-    logOp("mindos_create_space", { name, parent_path }, "ok", p);
+    _logOp("mindos_create_space", { name, parent_path }, "ok", p);
     return ok(`Created Mind Space at "${p}"`);
   } catch (e) {
-    logOp("mindos_create_space", { name, parent_path }, "error", String(e));
+    _logOp("mindos_create_space", { name, parent_path }, "error", String(e));
     return error(String(e));
   }
 });
@@ -273,11 +286,11 @@ server.registerTool("mindos_rename_space", {
   }),
 }, async ({ path: spacePath, new_name }) => {
   try {
-    const json = await post("/api/file", { op: "rename_space", path: spacePath, new_name });
-    logOp("mindos_rename_space", { path: spacePath, new_name }, "ok", String(json.newPath));
+    const json = await _post("/api/file", { op: "rename_space", path: spacePath, new_name });
+    _logOp("mindos_rename_space", { path: spacePath, new_name }, "ok", String(json.newPath));
     return ok(`Renamed space "${spacePath}" → "${json.newPath}"`);
   } catch (e) {
-    logOp("mindos_rename_space", { path: spacePath, new_name }, "error", String(e));
+    _logOp("mindos_rename_space", { path: spacePath, new_name }, "error", String(e));
     return error(String(e));
   }
 });
@@ -286,17 +299,18 @@ server.registerTool("mindos_rename_space", {
 
 server.registerTool("mindos_delete_file", {
   title: "Delete File",
-  description: "Permanently delete a file from the knowledge base.",
+  description: "Delete a file from the knowledge base. The file is moved to trash and can be recovered within 30 days.",
   inputSchema: z.object({
     path: z.string().min(1),
   }),
   annotations: { destructiveHint: true },
 }, async ({ path }) => {
   try {
-    await post("/api/file", { op: "delete_file", path });
-    logOp("mindos_delete_file", { path }, "ok", `Deleted "${path}"`);
-    return ok(`Deleted "${path}"`);
-  } catch (e) { logOp("mindos_delete_file", { path }, "error", String(e)); return error(String(e)); }
+    const res = await _post("/api/file", { op: "delete_file", path });
+    const trashId = res?.trashId ? ` (trashId: ${res.trashId})` : '';
+    _logOp("mindos_delete_file", { path }, "ok", `Moved to trash: "${path}"${trashId}`);
+    return ok(`Moved to trash: "${path}"${trashId}`);
+  } catch (e) { _logOp("mindos_delete_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_rename_file ──────────────────────────────────────────────────────
@@ -310,7 +324,7 @@ server.registerTool("mindos_rename_file", {
   }),
 }, async ({ path, new_name }) => {
   try {
-    const json = await post("/api/file", { op: "rename_file", path, new_name });
+    const json = await _post("/api/file", { op: "rename_file", path, new_name });
     return ok(`Renamed "${path}" → "${json.newPath}"`);
   } catch (e) { return error(String(e)); }
 });
@@ -326,7 +340,7 @@ server.registerTool("mindos_move_file", {
   }),
 }, async ({ from_path, to_path }) => {
   try {
-    const json = await post("/api/file", { op: "move_file", path: from_path, to_path });
+    const json = await _post("/api/file", { op: "move_file", path: from_path, to_path });
     const affected = json.affectedFiles as string[] ?? [];
     const lines = [`Moved "${from_path}" → "${json.newPath}"`];
     if (affected.length > 0) {
@@ -358,10 +372,10 @@ server.registerTool("mindos_search_notes", {
     if (file_type !== "all") params.file_type = file_type;
     if (modified_after) params.modified_after = modified_after;
     if (response_format) params.format = response_format;
-    const json = await get("/api/search", params);
-    logOp("mindos_search_notes", { query, limit }, "ok", `Search completed`);
+    const json = await _get("/api/search", params);
+    _logOp("mindos_search_notes", { query, limit }, "ok", `Search completed`);
     return ok(truncate(JSON.stringify(json, null, 2)));
-  } catch (e) { logOp("mindos_search_notes", { query }, "error", String(e)); return error(String(e)); }
+  } catch (e) { _logOp("mindos_search_notes", { query }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_get_recent ───────────────────────────────────────────────────────
@@ -376,7 +390,7 @@ server.registerTool("mindos_get_recent", {
   annotations: { readOnlyHint: true },
 }, async ({ limit, response_format }) => {
   try {
-    const json = await get("/api/recent-files", { limit: String(limit), format: response_format });
+    const json = await _get("/api/recent-files", { limit: String(limit), format: response_format });
     return ok(JSON.stringify(json, null, 2));
   } catch (e) { return error(String(e)); }
 });
@@ -392,7 +406,7 @@ server.registerTool("mindos_read_lines", {
   annotations: { readOnlyHint: true },
 }, async ({ path }) => {
   try {
-    const json = await get("/api/file", { path, op: "read_lines" });
+    const json = await _get("/api/file", { path, op: "read_lines" });
     const lines = json.lines as string[];
     const numbered = lines.map((l, i) => `${i}: ${l}`).join("\n");
     return ok(`${lines.length} lines total:\n\n${numbered}`);
@@ -411,7 +425,7 @@ server.registerTool("mindos_insert_lines", {
   }),
 }, async ({ path, after_index, lines }) => {
   try {
-    await post("/api/file", { op: "insert_lines", path, after_index, lines });
+    await _post("/api/file", { op: "insert_lines", path, after_index, lines });
     return ok(`Inserted ${lines.length} line(s) after index ${after_index} in "${path}"`);
   } catch (e) { return error(String(e)); }
 });
@@ -429,7 +443,7 @@ server.registerTool("mindos_update_lines", {
   }),
 }, async ({ path, start, end, lines }) => {
   try {
-    await post("/api/file", { op: "update_lines", path, start, end, lines });
+    await _post("/api/file", { op: "update_lines", path, start, end, lines });
     return ok(`Replaced lines ${start}–${end} in "${path}" with ${lines.length} new line(s)`);
   } catch (e) { return error(String(e)); }
 });
@@ -445,10 +459,10 @@ server.registerTool("mindos_append_to_file", {
   }),
 }, async ({ path, content }) => {
   try {
-    await post("/api/file", { op: "append_to_file", path, content });
-    logOp("mindos_append_to_file", { path }, "ok", `Appended ${content.length} chars`);
+    await _post("/api/file", { op: "append_to_file", path, content });
+    _logOp("mindos_append_to_file", { path }, "ok", `Appended ${content.length} chars`);
     return ok(`Appended ${content.length} character(s) to "${path}"`);
-  } catch (e) { logOp("mindos_append_to_file", { path }, "error", String(e)); return error(String(e)); }
+  } catch (e) { _logOp("mindos_append_to_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_insert_after_heading ─────────────────────────────────────────────
@@ -463,10 +477,10 @@ server.registerTool("mindos_insert_after_heading", {
   }),
 }, async ({ path, heading, content }) => {
   try {
-    await post("/api/file", { op: "insert_after_heading", path, heading, content });
-    logOp("mindos_insert_after_heading", { path, heading }, "ok", `Inserted after "${heading}"`);
+    await _post("/api/file", { op: "insert_after_heading", path, heading, content });
+    _logOp("mindos_insert_after_heading", { path, heading }, "ok", `Inserted after "${heading}"`);
     return ok(`Inserted content after heading "${heading}" in "${path}"`);
-  } catch (e) { logOp("mindos_insert_after_heading", { path, heading }, "error", String(e)); return error(String(e)); }
+  } catch (e) { _logOp("mindos_insert_after_heading", { path, heading }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_update_section ───────────────────────────────────────────────────
@@ -481,10 +495,10 @@ server.registerTool("mindos_update_section", {
   }),
 }, async ({ path, heading, content }) => {
   try {
-    await post("/api/file", { op: "update_section", path, heading, content });
-    logOp("mindos_update_section", { path, heading }, "ok", `Updated section "${heading}"`);
+    await _post("/api/file", { op: "update_section", path, heading, content });
+    _logOp("mindos_update_section", { path, heading }, "ok", `Updated section "${heading}"`);
     return ok(`Updated section "${heading}" in "${path}"`);
-  } catch (e) { logOp("mindos_update_section", { path, heading }, "error", String(e)); return error(String(e)); }
+  } catch (e) { _logOp("mindos_update_section", { path, heading }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_append_csv ───────────────────────────────────────────────────────
@@ -498,7 +512,7 @@ server.registerTool("mindos_append_csv", {
   }),
 }, async ({ path, row }) => {
   try {
-    const json = await post("/api/file", { op: "append_csv", path, row });
+    const json = await _post("/api/file", { op: "append_csv", path, row });
     return ok(`Appended row to "${path}". File now has ${json.newRowCount} rows.`);
   } catch (e) { return error(String(e)); }
 });
@@ -514,7 +528,7 @@ server.registerTool("mindos_get_backlinks", {
   annotations: { readOnlyHint: true },
 }, async ({ path }) => {
   try {
-    const json = await get("/api/backlinks", { path });
+    const json = await _get("/api/backlinks", { path });
     return ok(JSON.stringify(json, null, 2));
   } catch (e) { return error(String(e)); }
 });
@@ -532,7 +546,7 @@ server.registerTool("mindos_bootstrap", {
   try {
     const params: Record<string, string> = {};
     if (target_dir) params.target_dir = target_dir;
-    const json = await get("/api/bootstrap", params);
+    const json = await _get("/api/bootstrap", params);
     const sections = Object.entries(json)
       .filter(([, v]) => v !== undefined && v !== null)
       .map(([key, val]) => `--- ${key} ---\n\n${val}`)
@@ -553,7 +567,7 @@ server.registerTool("mindos_get_history", {
   annotations: { readOnlyHint: true },
 }, async ({ path, limit }) => {
   try {
-    const json = await get("/api/git", { op: "history", path, limit: String(limit) });
+    const json = await _get("/api/git", { op: "history", path, limit: String(limit) });
     const entries = json.entries as Array<{ hash: string; date: string; message: string; author: string }>;
     if (entries.length === 0) return ok(`No git history found for "${path}"`);
     const lines = [`# Git History: ${path}`, "", `${entries.length} commit(s):`, ""];
@@ -576,7 +590,7 @@ server.registerTool("mindos_get_file_at_version", {
   annotations: { readOnlyHint: true },
 }, async ({ path, commit }) => {
   try {
-    const json = await get("/api/git", { op: "show", path, commit });
+    const json = await _get("/api/git", { op: "show", path, commit });
     const content = json.content as string;
     return ok(truncate(`# ${path} @ ${commit.slice(0, 8)}\n\n${content}`));
   } catch (e) { return error(String(e)); }
@@ -648,7 +662,9 @@ async function main() {
       const sid = transport.sessionId;
       if (sid) {
         sessions.set(sid, { transport, server });
-        console.error(`[MCP] New session ${sid.slice(0, 8)} (${sessions.size} active)`);
+        const client = server.server.getClientVersion();
+        const clientLabel = client?.name ? ` (${client.name})` : '';
+        console.error(`[MCP] New session ${sid.slice(0, 8)}${clientLabel} (${sessions.size} active)`);
       }
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.6.38",
+  "version": "0.6.40",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",

package/scripts/build-runtime-archive.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+# Build a minimal MindOS runtime archive for Desktop Core Hot Update.
+# Output: /tmp/mindos-runtime-{VERSION}.tar.gz (pre-built, ~32MB)
+#
+# Directory structure matches what ProcessManager + analyzeMindOsLayout expect:
+#   app/.next/standalone/server.js
+#   app/.next/standalone/node_modules/
+#   app/.next/standalone/.next/server/
+#   app/.next/standalone/.next/static/
+#   app/.next/standalone/public/
+#   app/.next/static/            (isBundledRuntimeIntact checks this)
+#   app/public/
+#   mcp/dist/index.cjs
+#   package.json
+#   bin/ templates/ skills/
+set -euo pipefail
+
+VERSION=$(node -p "require('./package.json').version")
+WORK="/tmp/mindos-runtime-build-$$"
+ARCHIVE="/tmp/mindos-runtime-${VERSION}.tar.gz"
+rm -rf "$WORK"
+
+echo "📦 Building MindOS runtime v${VERSION}..."
+
+# ── Web server (standalone Next.js) ──
+echo "  Copying standalone..."
+mkdir -p "$WORK/app/.next"
+# Copy the entire standalone tree (server.js + node_modules + .next/server + .next/static + public)
+cp -r app/.next/standalone "$WORK/app/.next/standalone"
+# Remove dev artifacts that sneak into standalone
+rm -rf "$WORK/app/.next/standalone/.next/cache" \
+       "$WORK/app/.next/standalone/.next/dev" \
+       "$WORK/app/.next/standalone/.next/diagnostics" \
+       "$WORK/app/.next/standalone/.next/types" \
+       "$WORK/app/.next/standalone/__tests__" \
+       "$WORK/app/.next/standalone/.next/lock"
+# Copy static assets at top level (isBundledRuntimeIntact checks app/.next/static/)
+cp -r app/.next/static "$WORK/app/.next/static"
+# Copy public assets
+mkdir -p "$WORK/app"
+cp -r app/public "$WORK/app/public"
+
+# ── MCP server ──
+echo "  Copying MCP..."
+mkdir -p "$WORK/mcp/dist"
+cp mcp/dist/index.cjs "$WORK/mcp/dist/"
+[ -f mcp/package.json ] && cp mcp/package.json "$WORK/mcp/"
+
+# ── Metadata + auxiliary files ──
+echo "  Copying metadata..."
+cp package.json "$WORK/"
+[ -d bin ] && cp -r bin "$WORK/"
+[ -d templates ] && cp -r templates "$WORK/"
+[ -d skills ] && cp -r skills "$WORK/"
+
+# ── Package (flat, no outer directory) ──
+echo "  Creating archive..."
+tar czf "$ARCHIVE" -C "$WORK" .
+
+# ── Self-validation ──
+echo "  Validating..."
+VERIFY="/tmp/mindos-runtime-verify-$$"
+rm -rf "$VERIFY" && mkdir -p "$VERIFY"
+tar xzf "$ARCHIVE" -C "$VERIFY"
+
+ERRORS=0
+for f in \
+  "app/.next/standalone/server.js" \
+  "app/.next/standalone/node_modules" \
+  "app/.next/standalone/.next/server" \
+  "app/.next/static" \
+  "mcp/dist/index.cjs" \
+  "package.json"; do
+  if [ ! -e "$VERIFY/$f" ]; then
+    echo "  ❌ MISSING: $f"
+    ERRORS=$((ERRORS + 1))
+  fi
+done
+
+# Verify version in package.json matches
+PKG_VER=$(node -p "require('$VERIFY/package.json').version" 2>/dev/null || echo "")
+if [ "$PKG_VER" != "$VERSION" ]; then
+  echo "  ❌ Version mismatch: package.json=$PKG_VER, expected=$VERSION"
+  ERRORS=$((ERRORS + 1))
+fi
+
+rm -rf "$VERIFY" "$WORK"
+
+if [ "$ERRORS" -gt 0 ]; then
+  echo "❌ Validation failed with $ERRORS error(s)"
+  exit 1
+fi
+
+# ── Output info ──
+if command -v sha256sum >/dev/null 2>&1; then
+  SHA256=$(sha256sum "$ARCHIVE" | cut -d' ' -f1)
+else
+  SHA256=$(shasum -a 256 "$ARCHIVE" | cut -d' ' -f1)
+fi
+
+if command -v numfmt >/dev/null 2>&1; then
+  SIZE_HUMAN=$(stat -c%s "$ARCHIVE" | numfmt --to=iec)
+  SIZE_BYTES=$(stat -c%s "$ARCHIVE")
+elif command -v stat >/dev/null 2>&1; then
+  SIZE_BYTES=$(stat -f%z "$ARCHIVE" 2>/dev/null || stat -c%s "$ARCHIVE" 2>/dev/null)
+  SIZE_HUMAN="${SIZE_BYTES} bytes"
+fi
+
+echo ""
+echo "✅ mindos-runtime-${VERSION}.tar.gz"
+echo "   Size:   ${SIZE_HUMAN} (${SIZE_BYTES} bytes)"
+echo "   SHA256: ${SHA256}"
+echo "   Path:   ${ARCHIVE}"

package/scripts/setup.js

@@ -1228,7 +1228,7 @@ async function main() {
   console.log(`\n${c.green(t('cfgSaved'))}: ${c.dim(CONFIG_PATH)}`);
 
   // ── Skill rules are now built into SKILL.md — no install needed ──────────
-  // user-skill-rules.md will be created on first preference capture or via `mindos init-skills`.
+  // .mindos/user-preferences.md will be created on first preference capture or via `mindos init-skills`.
 
   // ── Step 7: MCP Agent Install ──────────────────────────────────────────────
   write('\n');

package/skills/mindos/SKILL.md

@@ -7,17 +7,21 @@ description: >
   Use when the task targets files inside the user's MindOS KB (mindRoot).
   NOT for editing app source, project docs, or paths outside the KB.
   Core concepts: Space, Instruction (INSTRUCTION.md), Skill (SKILL.md); notes can embody both.
+  Trigger when user asks to: save or record a note, search their knowledge base, update or edit
+  a file, organize notes, run a workflow or SOP, capture decisions from a session, append rows
+  to a table or CSV, hand off context to another agent — or says "帮我记下来" / "搜一下我的笔记" /
+  "更新知识库" / "整理文件" / "执行工作流".
 ---
 
 # MindOS Skill
 
-<!-- version: 1.3.1 -->
+<!-- version: 1.3.2 -->
 
 **Before every task, internalize these 5 rules:**
 
 1. The **bootstrap directory tree is the primary index** — reason from names and hierarchy before calling search. Most questions can be answered by reading what's already in context.
 2. **Default to read-only.** Only invoke write tools when the user explicitly asks to save, record, organize, or edit. Lookup / summarize / quote = no writes.
-3. **Rule precedence** (highest wins): user's current-turn instruction → `user-skill-rules.md` → nearest directory `INSTRUCTION.md` → root `INSTRUCTION.md` → this SKILL's defaults.
+3. **Rule precedence** (highest wins): user's current-turn instruction → `.mindos/user-preferences.md` → nearest directory `INSTRUCTION.md` → root `INSTRUCTION.md` → this SKILL's defaults.
 4. **Multi-file edits require a plan first.** Present the full change list; execute only after approval.
 5. After create/delete/move/rename → **sync affected READMEs** automatically.
 
@@ -83,8 +87,7 @@ User request
       └─ ASK for clarification. Propose 2-3 specific options based on KB state. Do NOT start editing.
 ```
 
-**For any write/SOP/structural path above → read [references/write-supplement.md](./references/write-supplement.md) first.**
-It covers: startup protocol, write tool selection, and step-by-step execution details for each path.
+**For any write/SOP/structural path above → the write supplement is already loaded in context (see `## Write & Workflow Supplement` section below or in the next context block).**
 
 ---
 
@@ -97,7 +100,7 @@ It covers: startup protocol, write tool selection, and step-by-step execution de
 | Find files | `mindos_search_notes` (2-4 parallel keyword variants) | Single-keyword search |
 | Read content | `mindos_read_file` or `mindos_read_lines` (for large files) | Reading entire large file when you need 10 lines |
 
-Write, structural, and history tools → [references/write-supplement.md](./references/write-supplement.md).
+Write, structural, and history tools → see Write & Workflow Supplement (loaded below or in next context block).
 
 ### Fallbacks
 
@@ -112,21 +115,33 @@ Write, structural, and history tools → [references/write-supplement.md](./refe
 |---------|------|-----------|
 | **Read-only Q&A** | Lookup / summarize / quote | Tree reasoning → search → read → answer with citations → state gaps |
 
-For write, SOP, structural, and handoff patterns → [references/write-supplement.md](./references/write-supplement.md).
+For write, SOP, structural, and handoff patterns → see Write & Workflow Supplement (loaded below or in next context block).
 
 ---
 
-## Interaction rules
+## Judgment heuristics
 
-- **Ambiguous request?** Ask first. Propose 2-3 options based on KB state (recent changes, directory structure). Never start reorganizing without understanding scope.
-- **Cite sources.** Every fact from the KB gets a file path so the user can verify.
-- **Brevity first.** Show the most likely match, not an exhaustive list.
+**Save intent — read vs. write boundary**
+- "帮我记下来" / "记录一下" / "保存这个" = write
+- "搜一下有没有关于 X 的笔记" / "总结上周的工作" = read-only
+- Ambiguous boundary ("整理一下这些内容") → ask first: display only, or write back to KB?
+
+**File location uncertainty**
+- 扫目录树 5 秒内定不下来 → don't invent a new directory; use the nearest semantically-fit existing one and inform the user
+- User says "just put it somewhere" → place in inbox or top-level general directory, propose classification after (triggers Structure classification hook)
+
+**Scope creep signals**
+- Single input routes to >5 files → pause, confirm scope; users rarely intend bulk rewrites
+- "Update all of these" + content spans multiple topics → split into batches, confirm each, don't execute all at once
+
+**Citation discipline**
+- KB-cited facts must include the file path so the user can verify
 
 ---
 
 ## Post-task hooks
 
-After **write tasks** (not simple single-file edits or read-only), scan this table. If a condition matches, make a one-line proposal. At most 1 proposal; pick highest priority. Check `user-skill-rules.md` suppression section first. Skip all if user asked for quiet mode.
+After **write tasks** (not simple single-file edits or read-only), scan this table. If a condition matches, make a one-line proposal. At most 1 proposal; pick highest priority. Check `.mindos/user-preferences.md` suppression section first. Skip all if user asked for quiet mode.
 
 | Hook | Priority | Condition |
 |------|----------|-----------|
@@ -142,7 +157,7 @@ If a hook triggers → read [references/post-task-hooks.md](./references/post-ta
 
 ## Preference capture
 
-When the user expresses a standing preference ("don't do X", "always put Y in Z"), read [references/preference-capture.md](./references/preference-capture.md) and follow the confirm-then-write flow to `user-skill-rules.md`.
+When the user expresses a standing preference ("don't do X", "always put Y in Z"), read [references/preference-capture.md](./references/preference-capture.md) and follow the confirm-then-write flow to `.mindos/user-preferences.md`.
 **Do NOT read** preference-capture unless the user actually expressed a preference to persist.
 
 ## SOP authoring