@geminilight/mindos 0.5.11 → 0.5.13

package/app/lib/agent/tools.ts

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import {
   searchFiles, getFileContent, getFileTree, getRecentlyModified,
   saveFileContent, createFile, appendToFile, insertAfterHeading, updateSection,
+  deleteFile, renameFile, moveFile, findBacklinks, gitLog, gitShowFile, appendCsvRow,
 } from '@/lib/fs';
 import { assertNotProtected } from '@/lib/core';
 import { logAgentOp } from './log';
@@ -44,11 +45,44 @@ function logged<P extends Record<string, unknown>>(
 
 export const knowledgeBaseTools = {
   list_files: tool({
-    description: 'List the full file tree of the knowledge base. Use this to browse what files exist.',
-    inputSchema: z.object({}),
-    execute: logged('list_files', async () => {
+    description: 'List files in the knowledge base as an indented tree. Directories beyond `depth` show "... (N items)". Pass `path` to list only a subdirectory, or `depth` to control how deep to expand (default 3).',
+    inputSchema: z.object({
+      path: z.string().optional().describe('Optional subdirectory to list (e.g. "Projects/Products"). Omit to list everything.'),
+      depth: z.number().min(1).max(10).optional().describe('Max tree depth to expand (default 3). Directories deeper than this show item count only.'),
+    }),
+    execute: logged('list_files', async ({ path: subdir, depth: maxDepth }) => {
       const tree = getFileTree();
-      return JSON.stringify(tree, null, 2);
+      const limit = maxDepth ?? 3;
+      const lines: string[] = [];
+      function walk(nodes: Array<{ name: string; type: string; children?: unknown[] }>, depth: number) {
+        for (const n of nodes) {
+          lines.push('  '.repeat(depth) + (n.type === 'directory' ? `${n.name}/` : n.name));
+          if (n.type === 'directory' && Array.isArray(n.children)) {
+            if (depth + 1 < limit) {
+              walk(n.children as typeof nodes, depth + 1);
+            } else {
+              lines.push('  '.repeat(depth + 1) + `... (${n.children.length} items)`);
+            }
+          }
+        }
+      }
+
+      if (subdir) {
+        const segments = subdir.replace(/\/$/, '').split('/').filter(Boolean);
+        let current: Array<{ name: string; type: string; path?: string; children?: unknown[] }> = tree as any;
+        for (const seg of segments) {
+          const found = current.find(n => n.name === seg && n.type === 'directory');
+          if (!found || !Array.isArray(found.children)) {
+            return `Directory not found: ${subdir}`;
+          }
+          current = found.children as typeof current;
+        }
+        walk(current as any, 0);
+      } else {
+        walk(tree as any, 0);
+      }
+
+      return lines.length > 0 ? lines.join('\n') : '(empty directory)';
     }),
   }),
 
@@ -169,4 +203,125 @@ export const knowledgeBaseTools = {
       }
     }),
   }),
+
+  // ─── New tools (Phase 1a) ──────────────────────────────────────────────────
+
+  delete_file: tool({
+    description: 'Permanently delete a file from the knowledge base. This is destructive and cannot be undone.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path to delete'),
+    }),
+    execute: logged('delete_file', async ({ path }) => {
+      try {
+        assertWritable(path);
+        deleteFile(path);
+        return `File deleted: ${path}`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  rename_file: tool({
+    description: 'Rename a file within its current directory. Only the filename changes, not the directory.',
+    inputSchema: z.object({
+      path: z.string().describe('Current relative file path'),
+      new_name: z.string().describe('New filename (no path separators, e.g. "new-name.md")'),
+    }),
+    execute: logged('rename_file', async ({ path, new_name }) => {
+      try {
+        assertWritable(path);
+        const newPath = renameFile(path, new_name);
+        return `File renamed: ${path} → ${newPath}`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  move_file: tool({
+    description: 'Move a file to a new location. Also returns any files that had backlinks affected by the move.',
+    inputSchema: z.object({
+      from_path: z.string().describe('Current relative file path'),
+      to_path: z.string().describe('New relative file path'),
+    }),
+    execute: logged('move_file', async ({ from_path, to_path }) => {
+      try {
+        assertWritable(from_path);
+        const result = moveFile(from_path, to_path);
+        const affected = result.affectedFiles.length > 0
+          ? `\nAffected backlinks in: ${result.affectedFiles.join(', ')}`
+          : '';
+        return `File moved: ${from_path} → ${result.newPath}${affected}`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  get_backlinks: tool({
+    description: 'Find all files that reference a given file path. Useful for understanding connections between notes.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path to find backlinks for'),
+    }),
+    execute: logged('get_backlinks', async ({ path }) => {
+      try {
+        const backlinks = findBacklinks(path);
+        if (backlinks.length === 0) return `No backlinks found for: ${path}`;
+        return backlinks.map(b => `- **${b.source}** (L${b.line}): ${b.context}`).join('\n');
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  get_history: tool({
+    description: 'Get git commit history for a file. Shows recent commits that modified this file.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path'),
+      limit: z.number().min(1).max(50).default(10).describe('Number of commits to return'),
+    }),
+    execute: logged('get_history', async ({ path, limit }) => {
+      try {
+        const commits = gitLog(path, limit);
+        if (commits.length === 0) return `No git history found for: ${path}`;
+        return commits.map(c => `- \`${c.hash.slice(0, 7)}\` ${c.date} — ${c.message} (${c.author})`).join('\n');
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  get_file_at_version: tool({
+    description: 'Read the content of a file at a specific git commit. Use get_history first to find commit hashes.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path'),
+      commit: z.string().describe('Git commit hash (full or abbreviated)'),
+    }),
+    execute: logged('get_file_at_version', async ({ path, commit }) => {
+      try {
+        const content = gitShowFile(path, commit);
+        return truncate(content);
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  append_csv: tool({
+    description: 'Append a row to a CSV file. Values are automatically escaped per RFC 4180.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative path to .csv file'),
+      row: z.array(z.string()).describe('Array of cell values for the new row'),
+    }),
+    execute: logged('append_csv', async ({ path, row }) => {
+      try {
+        assertWritable(path);
+        const result = appendCsvRow(path, row);
+        return `Row appended to ${path} (now ${result.newRowCount} rows)`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
 };

package/app/lib/i18n.ts

@@ -72,6 +72,7 @@ export const messages = {
       stopTitle: 'Stop',
       connecting: 'Thinking with your mind...',
       thinking: 'Thinking...',
+      thinkingLabel: 'Thinking',
       searching: 'Searching knowledge base...',
       generating: 'Generating response...',
       stopped: 'Generation stopped.',
@@ -129,6 +130,19 @@ export const messages = {
         testKeyNoKey: 'No API key configured',
         testKeyUnknown: 'Test failed',
       },
+      agent: {
+        title: 'Agent Behavior',
+        maxSteps: 'Max Steps',
+        maxStepsHint: 'Maximum tool call steps per request (1-30)',
+        contextStrategy: 'Context Strategy',
+        contextStrategyHint: 'Auto: summarize early messages when context fills up. Off: no summarization (emergency pruning still applies).',
+        contextStrategyAuto: 'Auto (compact + prune)',
+        contextStrategyOff: 'Off',
+        thinking: 'Extended Thinking',
+        thinkingHint: "Show Claude's reasoning process (uses more tokens)",
+        thinkingBudget: 'Thinking Budget',
+        thinkingBudgetHint: 'Max tokens for reasoning (1000-50000)',
+      },
       appearance: {
         readingFont: 'Reading font',
         contentWidth: 'Content width',
@@ -476,6 +490,7 @@ export const messages = {
       stopTitle: '停止',
       connecting: '正在与你的心智一起思考...' ,
       thinking: '思考中...',
+      thinkingLabel: '思考中',
       searching: '正在搜索知识库...',
       generating: '正在生成回复...',
       stopped: '已停止生成。',
@@ -533,6 +548,19 @@ export const messages = {
         testKeyNoKey: '未配置 API Key',
         testKeyUnknown: '测试失败',
       },
+      agent: {
+        title: 'Agent 行为',
+        maxSteps: '最大步数',
+        maxStepsHint: '每次请求的最大工具调用步数（1-30）',
+        contextStrategy: '上下文策略',
+        contextStrategyHint: '自动：上下文填满时摘要早期消息。关闭：不进行摘要（紧急裁剪仍会生效）。',
+        contextStrategyAuto: '自动（压缩 + 裁剪）',
+        contextStrategyOff: '关闭',
+        thinking: '深度思考',
+        thinkingHint: '显示 Claude 的推理过程（消耗更多 token）',
+        thinkingBudget: '思考预算',
+        thinkingBudgetHint: '推理最大 token 数（1000-50000）',
+      },
       appearance: {
         readingFont: '正文字体',
         contentWidth: '内容宽度',

package/app/lib/settings.ts

@@ -18,8 +18,16 @@ export interface AiConfig {
   };
 }
 
+export interface AgentConfig {
+  maxSteps?: number;          // default 20, range 1-30
+  enableThinking?: boolean;   // default false, Anthropic only
+  thinkingBudget?: number;    // default 5000
+  contextStrategy?: 'auto' | 'off'; // default 'auto'
+}
+
 export interface ServerSettings {
   ai: AiConfig;
+  agent?: AgentConfig;
   mindRoot: string;   // empty = use env var / default
   port?: number;
   mcpPort?: number;
@@ -99,12 +107,25 @@ function migrateAi(parsed: Record<string, unknown>): AiConfig {
   };
 }
 
+/** Parse agent config from unknown input */
+function parseAgent(raw: unknown): AgentConfig | undefined {
+  if (!raw || typeof raw !== 'object') return undefined;
+  const obj = raw as Record<string, unknown>;
+  const result: AgentConfig = {};
+  if (typeof obj.maxSteps === 'number') result.maxSteps = Math.min(30, Math.max(1, obj.maxSteps));
+  if (typeof obj.enableThinking === 'boolean') result.enableThinking = obj.enableThinking;
+  if (typeof obj.thinkingBudget === 'number') result.thinkingBudget = Math.min(50000, Math.max(1000, obj.thinkingBudget));
+  if (obj.contextStrategy === 'auto' || obj.contextStrategy === 'off') result.contextStrategy = obj.contextStrategy;
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 export function readSettings(): ServerSettings {
   try {
     const raw = fs.readFileSync(SETTINGS_PATH, 'utf-8');
     const parsed = JSON.parse(raw) as Record<string, unknown>;
     return {
       ai: migrateAi(parsed),
+      agent: parseAgent(parsed.agent),
       mindRoot: (parsed.mindRoot ?? parsed.sopRoot ?? DEFAULTS.mindRoot) as string,
       webPassword: typeof parsed.webPassword === 'string' ? parsed.webPassword : undefined,
       authToken:   typeof parsed.authToken   === 'string' ? parsed.authToken   : undefined,
@@ -126,6 +147,7 @@ export function writeSettings(settings: ServerSettings): void {
   let existing: Record<string, unknown> = {};
   try { existing = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf-8')); } catch { /* ignore */ }
   const merged: Record<string, unknown> = { ...existing, ai: settings.ai, mindRoot: settings.mindRoot };
+  if (settings.agent !== undefined) merged.agent = settings.agent;
   if (settings.webPassword !== undefined) merged.webPassword = settings.webPassword;
   if (settings.authToken   !== undefined) merged.authToken   = settings.authToken;
   if (settings.port        !== undefined) merged.port        = settings.port;

package/app/lib/types.ts

@@ -13,9 +13,32 @@ export interface BacklinkItem {
   snippets: string[];
 }
 
+export interface ToolCallPart {
+  type: 'tool-call';
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  output?: string;
+  state: 'pending' | 'running' | 'done' | 'error';
+}
+
+export interface TextPart {
+  type: 'text';
+  text: string;
+}
+
+export interface ReasoningPart {
+  type: 'reasoning';
+  text: string;
+}
+
+export type MessagePart = TextPart | ToolCallPart | ReasoningPart;
+
 export interface Message {
   role: 'user' | 'assistant';
   content: string;
+  /** Structured parts for assistant messages (tool calls + text segments) */
+  parts?: MessagePart[];
 }
 
 export interface LocalAttachment {

package/app/package.json

@@ -3,17 +3,16 @@
   "version": "0.1.0",
   "private": true,
   "scripts": {
-    "dev": "next dev -p ${MINDOS_WEB_PORT:-3000}",
+    "dev": "next dev -p ${MINDOS_WEB_PORT:-3456}",
     "prebuild": "node ../scripts/gen-renderer-index.js",
     "build": "next build",
-    "start": "next start -p ${MINDOS_WEB_PORT:-3000}",
+    "start": "next start -p ${MINDOS_WEB_PORT:-3456}",
     "lint": "eslint",
     "test": "vitest run"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.58",
     "@ai-sdk/openai": "^3.0.41",
-    "@ai-sdk/react": "^3.0.118",
     "@base-ui/react": "^1.2.0",
     "@codemirror/lang-markdown": "^6.5.0",
     "@codemirror/state": "^6.5.4",

package/bin/cli.js

@@ -50,7 +50,7 @@ import { needsBuild, writeBuildStamp, clearBuildLock, cleanNextDir, ensureAppDep
 import { isPortInUse, assertPortFree } from './lib/port.js';
 import { savePids, clearPids } from './lib/pid.js';
 import { stopMindos } from './lib/stop.js';
-import { getPlatform, ensureMindosDir, waitForHttp, runGatewayCommand } from './lib/gateway.js';
+import { getPlatform, ensureMindosDir, waitForHttp, waitForPortFree, runGatewayCommand } from './lib/gateway.js';
 import { printStartupInfo, getLocalIP } from './lib/startup.js';
 import { spawnMcp } from './lib/mcp-spawn.js';
 import { mcpInstall } from './lib/mcp-install.js';
@@ -84,7 +84,7 @@ const commands = {
   // ── open ───────────────────────────────────────────────────────────────────
   open: () => {
     loadConfig();
-    const webPort = process.env.MINDOS_WEB_PORT || '3000';
+    const webPort = process.env.MINDOS_WEB_PORT || '3456';
     const url = `http://localhost:${webPort}`;
     let cmd;
     if (process.platform === 'darwin') {
@@ -121,7 +121,7 @@ const commands = {
       console.log(dim('No auth token set. Run `mindos onboard` to configure one.'));
       process.exit(0);
     }
-    const mcpPort = config.mcpPort || 8787;
+    const mcpPort = config.mcpPort || 8781;
     const localIP = getLocalIP();
 
     const localUrl = `http://localhost:${mcpPort}/mcp`;
@@ -197,8 +197,8 @@ const commands = {
   // ── dev ────────────────────────────────────────────────────────────────────
   dev: async () => {
     loadConfig();
-    const webPort = process.env.MINDOS_WEB_PORT || '3000';
-    const mcpPort = process.env.MINDOS_MCP_PORT || '8787';
+    const webPort = process.env.MINDOS_WEB_PORT || '3456';
+    const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
     await assertPortFree(Number(webPort), 'web');
     await assertPortFree(Number(mcpPort), 'mcp');
     ensureAppDeps();
@@ -231,11 +231,13 @@ const commands = {
         console.warn(yellow('Warning: daemon mode not supported on this platform. Falling back to foreground.'));
       } else {
         loadConfig();
-        const webPort = process.env.MINDOS_WEB_PORT || '3000';
-        const mcpPort = process.env.MINDOS_MCP_PORT || '8787';
+        const webPort = process.env.MINDOS_WEB_PORT || '3456';
+        const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
         console.log(cyan(`Installing MindOS as a background service (${platform})...`));
         await runGatewayCommand('install');
-        await runGatewayCommand('start');
+        // install() already starts the service via launchctl bootstrap + RunAtLoad=true.
+        // Do NOT call start() here — kickstart -k would kill the just-started process,
+        // causing a port-conflict race condition with KeepAlive restart loops.
         console.log(dim('  (First run may take a few minutes to install dependencies and build the app.)'));
         console.log(dim('  Follow live progress with:  mindos logs\n'));
         const ready = await waitForHttp(Number(webPort), { retries: 120, intervalMs: 2000, label: 'Web UI' });
@@ -261,10 +263,26 @@ const commands = {
       }
     }
     loadConfig();
-    const webPort = process.env.MINDOS_WEB_PORT || '3000';
-    const mcpPort = process.env.MINDOS_MCP_PORT || '8787';
-    await assertPortFree(Number(webPort), 'web');
-    await assertPortFree(Number(mcpPort), 'mcp');
+    const webPort = process.env.MINDOS_WEB_PORT || '3456';
+    const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
+
+    // When launched by a daemon manager (launchd/systemd), wait for ports to
+    // free instead of exiting immediately — the previous instance may still be
+    // shutting down after a restart/update.
+    const launchedByDaemon = process.env.LAUNCHED_BY_LAUNCHD === '1'
+      || !!process.env.INVOCATION_ID; /* systemd sets INVOCATION_ID */
+
+    if (launchedByDaemon) {
+      const webOk = await waitForPortFree(Number(webPort), { retries: 60, intervalMs: 500 });
+      const mcpOk = await waitForPortFree(Number(mcpPort), { retries: 60, intervalMs: 500 });
+      if (!webOk || !mcpOk) {
+        console.error('Ports still in use after 30s, exiting.');
+        process.exit(1);  // KeepAlive will retry after ThrottleInterval
+      }
+    } else {
+      await assertPortFree(Number(webPort), 'web');
+      await assertPortFree(Number(mcpPort), 'mcp');
+    }
     ensureAppDeps();
     if (needsBuild()) {
       console.log(yellow('Building MindOS (first run or new version detected)...\n'));
@@ -306,8 +324,8 @@ const commands = {
       run('npm install --prefer-offline --no-workspaces', resolve(ROOT, 'mcp'));
     }
     // Map config env vars to what the MCP server expects
-    const mcpPort = process.env.MINDOS_MCP_PORT || '8787';
-    const webPort = process.env.MINDOS_WEB_PORT || '3000';
+    const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
+    const webPort = process.env.MINDOS_WEB_PORT || '3456';
     process.env.MCP_PORT   = mcpPort;
     process.env.MINDOS_URL = `http://localhost:${webPort}`;
     run(`npx tsx src/index.ts`, resolve(ROOT, 'mcp'));
@@ -328,8 +346,8 @@ const commands = {
     loadConfig();
 
     // After loadConfig, env vars reflect the NEW config (or old if unchanged).
-    const newWebPort = Number(process.env.MINDOS_WEB_PORT || '3000');
-    const newMcpPort = Number(process.env.MINDOS_MCP_PORT || '8787');
+    const newWebPort = Number(process.env.MINDOS_WEB_PORT || '3456');
+    const newMcpPort = Number(process.env.MINDOS_MCP_PORT || '8781');
 
     // Collect old ports that differ from new ones — processes may still be
     // listening there even though config already points to the new ports.
@@ -465,8 +483,8 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
     }
 
     // 6. Ports
-    const webPort = Number(config?.port || process.env.MINDOS_WEB_PORT || 3000);
-    const mcpPort = Number(config?.mcpPort || process.env.MINDOS_MCP_PORT || 8787);
+    const webPort = Number(config?.port || process.env.MINDOS_WEB_PORT || 3456);
+    const mcpPort = Number(config?.mcpPort || process.env.MINDOS_MCP_PORT || 8781);
     const webInUse = await isPortInUse(webPort);
     const mcpInUse = await isPortInUse(mcpPort);
     if (webInUse) {
@@ -582,11 +600,13 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
       console.log(cyan('\n  Daemon is running — restarting to apply the new version...'));
       await runGatewayCommand('stop');
       await runGatewayCommand('install');
-      await runGatewayCommand('start');
+      // Note: install() already starts the service via launchctl bootstrap + RunAtLoad=true.
+      // Do NOT call start() here — kickstart -k would kill the just-started process,
+      // causing a port-conflict race condition with KeepAlive restart loops.
       const webPort = (() => {
-        try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).port ?? 3000; } catch { return 3000; }
+        try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).port ?? 3456; } catch { return 3456; }
       })();
-      console.log(dim('  (Waiting for Web UI to come back up...)'));
+      console.log(dim('  (Waiting for Web UI to come back up — first run after update includes a rebuild...)'));
       const ready = await waitForHttp(Number(webPort), { retries: 120, intervalMs: 2000, label: 'Web UI' });
       if (ready) {
         console.log(green('✔ MindOS restarted and ready.\n'));

package/bin/lib/build.js

@@ -38,9 +38,13 @@ export function cleanNextDir() {
 }
 
 function depsHash() {
-  const lockPath = resolve(ROOT, 'app', 'package-lock.json');
+  // Use package.json (not package-lock.json) so we don't need to ship the
+  // 560kB lock file in the npm tarball.  package.json changes whenever
+  // dependencies are added/removed/bumped, which is the only case that
+  // requires a fresh `npm install`.
+  const pkgPath = resolve(ROOT, 'app', 'package.json');
   try {
-    const content = readFileSync(lockPath);
+    const content = readFileSync(pkgPath);
     return createHash('sha256').update(content).digest('hex').slice(0, 16);
   } catch {
     return null;

package/bin/lib/gateway.js

@@ -1,5 +1,5 @@
 import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, statSync, renameSync, unlinkSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { MINDOS_DIR, LOG_PATH, CLI_PATH, NODE_BIN, CONFIG_PATH } from './constants.js';
@@ -8,6 +8,18 @@ import { isPortInUse } from './port.js';
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
+/** Rotate log file when it exceeds 2 MB. Keeps at most one .old backup. */
+function rotateLogs() {
+  try {
+    const stat = statSync(LOG_PATH);
+    if (stat.size > 2 * 1024 * 1024) {
+      const old = LOG_PATH + '.old';
+      try { unlinkSync(old); } catch {}
+      renameSync(LOG_PATH, old);
+    }
+  } catch { /* file doesn't exist yet, nothing to rotate */ }
+}
+
 export function getPlatform() {
   if (process.platform === 'darwin') return 'launchd';
   if (process.platform === 'linux')  return 'systemd';
@@ -72,6 +84,7 @@ const systemd = {
   install() {
     if (!existsSync(SYSTEMD_DIR)) mkdirSync(SYSTEMD_DIR, { recursive: true });
     ensureMindosDir();
+    rotateLogs();
     const currentPath = process.env.PATH ?? '/usr/local/bin:/usr/bin:/bin';
     const unit = [
       '[Unit]',
@@ -100,6 +113,7 @@ const systemd = {
   },
 
   async start() {
+    rotateLogs();
     execSync('systemctl --user start mindos', { stdio: 'inherit' });
     const ok = await waitForService(() => {
       try {
@@ -153,6 +167,7 @@ const launchd = {
   install() {
     if (!existsSync(LAUNCHD_DIR)) mkdirSync(LAUNCHD_DIR, { recursive: true });
     ensureMindosDir();
+    rotateLogs();
     const currentPath = process.env.PATH ?? '/usr/local/bin:/usr/bin:/bin';
     const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -166,13 +181,18 @@ const launchd = {
     <string>start</string>
   </array>
   <key>RunAtLoad</key><true/>
-  <key>KeepAlive</key><true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key><false/>
+  </dict>
+  <key>ThrottleInterval</key><integer>5</integer>
   <key>StandardOutPath</key><string>${LOG_PATH}</string>
   <key>StandardErrorPath</key><string>${LOG_PATH}</string>
   <key>EnvironmentVariables</key>
   <dict>
     <key>HOME</key><string>${homedir()}</string>
     <key>PATH</key><string>${currentPath}</string>
+    <key>LAUNCHED_BY_LAUNCHD</key><string>1</string>
   </dict>
 </dict>
 </plist>
@@ -192,6 +212,7 @@ const launchd = {
   },
 
   async start() {
+    rotateLogs();
     execSync(`launchctl kickstart -k gui/${launchctlUid()}/${LAUNCHD_LABEL}`, { stdio: 'inherit' });
     const ok = await waitForService(() => {
       try {
@@ -209,7 +230,7 @@ const launchd = {
 
   async stop() {
     // Read ports before bootout so we can wait for them to be freed
-    let webPort = 3000, mcpPort = 8787;
+    let webPort = 3456, mcpPort = 8781;
     try {
       const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
       if (config.port) webPort = Number(config.port);

package/bin/lib/mcp-install.js

@@ -253,8 +253,8 @@ export async function mcpInstall() {
     const ask2 = (q) => new Promise(r => rl2.question(q, r));
 
     if (!url) {
-      let mcpPort = 8787;
-      try { mcpPort = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).mcpPort || 8787; } catch {}
+      let mcpPort = 8781;
+      try { mcpPort = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).mcpPort || 8781; } catch {}
       const defaultUrl = `http://localhost:${mcpPort}/mcp`;
       url = hasYesFlag ? defaultUrl : (await ask2(`${bold('MCP URL')} ${dim(`[${defaultUrl}]:`)} `)).trim() || defaultUrl;
     }

package/bin/lib/mcp-spawn.js

@@ -5,8 +5,8 @@ import { ROOT } from './constants.js';
 import { bold, red, yellow } from './colors.js';
 
 export function spawnMcp(verbose = false) {
-  const mcpPort = process.env.MINDOS_MCP_PORT || '8787';
-  const webPort = process.env.MINDOS_WEB_PORT || '3000';
+  const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
+  const webPort = process.env.MINDOS_WEB_PORT || '3456';
   // Ensure mcp/node_modules exists (auto-install on first run)
   const mcpSdk = resolve(ROOT, 'mcp', 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json');
   if (!existsSync(mcpSdk)) {
@@ -16,7 +16,7 @@ export function spawnMcp(verbose = false) {
   const env = {
     ...process.env,
     MCP_PORT: mcpPort,
-    MINDOS_URL: `http://localhost:${webPort}`,
+    MINDOS_URL: process.env.MINDOS_URL || `http://127.0.0.1:${webPort}`,
     ...(verbose ? { MCP_VERBOSE: '1' } : {}),
   };
   const child = spawn('npx', ['tsx', 'src/index.ts'], {

package/bin/lib/stop.js

@@ -75,7 +75,7 @@ function killTree(pid) {
  */
 export function stopMindos(opts = {}) {
   // Read ports from config for port-based cleanup
-  let webPort = '3000', mcpPort = '8787';
+  let webPort = '3456', mcpPort = '8781';
   try {
     const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
     if (config.port) webPort = String(config.port);