@pheem49/mint 1.15.0 → 1.16.0

package/shared-modules/.github/workflows/ci.yml

@@ -0,0 +1,120 @@
+name: CI
+
+on:
+  push:
+    branches: master
+  pull_request:
+    branches: master
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  CI:
+    runs-on: ubuntu-latest
+    steps:
+        # 4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        with:
+          persist-credentials: false
+
+      - name: Set up dependencies
+        run: |
+          sudo add-apt-repository ppa:flatpak/stable
+          sudo apt-get update
+          sudo apt-get install -y flatpak dbus-daemon jq
+          flatpak remote-add --user --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+          flatpak install flathub -y org.flatpak.Builder
+
+      - name: Validate manifests
+        run: |
+          set -e
+          for i in $(find . -type f -name "*.json"); do flatpak run org.flatpak.Builder --show-manifest "$i"; done
+          rm -rf .flatpak-builder
+
+          find . -maxdepth 1 -mindepth 1 -type d ! -path './.github' ! -path './.git' | while read dir; do
+            if [ "$(find "$dir" -maxdepth 1 -type f -name '*.json' | wc -l)" -eq 0 ]; then
+              echo "Error: $dir has no JSON manifest"
+              exit 1
+            fi
+          done
+
+          files="$(find . -type f \( -name '*.yml' -o -name '*.yaml' \) ! -path './.github/*' ! -path './.git')"
+          if [ -n "$files" ]; then
+            echo "Error: YML/YAML file found: $files"
+            exit 1
+          fi
+
+      - name: Validate JSON
+        run: |
+          find . -type f -name '*.json' -exec sh -c 'for f do jq empty "$f" 2>&1 >/dev/null | sed "s|^|$f: |"; done' sh {} \;
+
+      - name: Build changed manifests against stable Freedesktop SDK
+        if: github.event_name == 'pull_request'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_REPO: ${{ github.repository }}
+        run: |
+          set -e
+          FILES=$(gh pr view "${{ github.event.number }}" --json files --jq '.files[].path')
+
+          for f in $FILES; do
+            if [[ "$f" == *.json && -f "$f" ]]; then
+              echo "Building manifest for $f"
+
+              RUNTIME_VERSION=$(flatpak remote-ls --columns=ref flathub \
+                | grep "runtime/org.freedesktop.Platform/x86_64/" \
+                | sed 's|.*/||' \
+                | sort -V \
+                | tail -n1)
+
+              cat > org.example.stable.yml <<EOF
+          id: org.example.stable
+          runtime: org.freedesktop.Platform
+          runtime-version: '$RUNTIME_VERSION'
+          sdk: org.freedesktop.Sdk
+          modules:
+            - $f
+          EOF
+
+              cat org.example.stable.yml
+              dbus-run-session flatpak run org.flatpak.Builder --verbose --user --force-clean \
+                --install-deps-from=flathub builddir org.example.stable.yml
+            fi
+          done
+
+      - name: Build changed manifests against oldstable Freedesktop SDK
+        if: github.event_name == 'pull_request'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_REPO: ${{ github.repository }}
+        run: |
+          set -e
+          FILES=$(gh pr view "${{ github.event.number }}" --json files --jq '.files[].path')
+
+          for f in $FILES; do
+            if [[ "$f" == *.json && -f "$f" ]]; then
+              echo "Building manifest for $f"
+
+              RUNTIME_VERSION=$(flatpak remote-ls --columns=ref flathub \
+                | grep "runtime/org.freedesktop.Platform/x86_64/" \
+                | sed 's|.*/||' \
+                | sort -V \
+                | tail -n2|head -1)
+
+              cat > org.example.oldstable.yml <<EOF
+          id: org.example.oldstable
+          runtime: org.freedesktop.Platform
+          runtime-version: '$RUNTIME_VERSION'
+          sdk: org.freedesktop.Sdk
+          modules:
+            - $f
+          EOF
+
+              cat org.example.oldstable.yml
+              dbus-run-session flatpak run org.flatpak.Builder --verbose --user --force-clean \
+                --install-deps-from=flathub builddir org.example.oldstable.yml
+            fi
+          done
+

package/shared-modules/.github/workflows/update.yaml

@@ -0,0 +1,28 @@
+name: Check for updates
+on:
+  schedule:
+    - cron: "0 0 1,21 * *"
+  workflow_dispatch:
+
+jobs:
+  flatpak-external-data-checker:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        branch: [ master ]
+    steps:
+        # 4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        with:
+          ref: ${{ matrix.branch }}
+
+      - uses: docker://ghcr.io/flathub-infra/flatpak-external-data-checker:latest@sha256:9e64f59dc8b92b4e7cf325a3f2ef98a64beaf721b58803801d3bf66269203221
+        env:
+          GIT_AUTHOR_NAME: flathubbot
+          GIT_COMMITTER_NAME: flathubbot
+          GIT_AUTHOR_EMAIL: sysadmin@flathub.org
+          GIT_COMMITTER_EMAIL: sysadmin@flathub.org
+          EMAIL: sysadmin@flathub.org
+          GITHUB_TOKEN: ${{ secrets.FLATHUBBOT_TOKEN }}
+        with:
+          entrypoint: ./update-checker.sh

package/slash-commands.json

@@ -1,5 +1,7 @@
 [
+  { "token": "/mint-web", "usage": "", "description": "Start Mint Web in a background terminal; stop it when Mint closes", "category": "system", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/help", "usage": "", "description": "Show this help", "category": "system", "surfaces": ["cli", "web", "desktop"] },
+  { "token": "/mods", "usage": "[list|source|validate|test|enable|disable|export|import|hot-reload]", "description": "Manage workspace mods, tests and live UI panels", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/theme", "usage": "", "description": "Choose terminal theme with a live preview", "category": "system", "surfaces": ["cli"] },
   { "token": "/init", "usage": "", "description": "Scan the codebase and write an AGENTS.md (build/test commands, architecture, conventions)", "category": "system", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/fast", "usage": "[on|off]", "description": "Toggle fast mode (hide thinking traces)", "category": "system", "surfaces": ["cli", "web", "desktop"] },
@@ -54,13 +56,14 @@
   { "token": "/search-provider", "usage": "[name]", "description": "List web search providers or switch default provider", "category": "models", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/bg", "usage": "<query>", "description": "Run a query in the background, non-blocking", "category": "tools", "surfaces": ["cli"] },
   { "token": "/jobs", "usage": "[show|cancel <id>]", "description": "List, inspect, or cancel background jobs", "category": "tools", "surfaces": ["cli"] },
-  { "token": "/shells", "usage": "", "description": "List, inspect, or kill background shell jobs run_shell started", "category": "tools", "surfaces": ["cli"] },
+  { "token": "/preview", "usage": "<relative HTML, Markdown, or image path>", "description": "Serve workspace HTML, Markdown, or images locally and return its browser URL", "category": "tools", "surfaces": ["cli", "desktop", "web"] },
+  { "token": "/shells", "usage": "[all|show <id>|stop <id>|kill <id>]", "description": "List background terminals, view output, or stop a job", "category": "tools", "surfaces": ["cli", "desktop", "web"] },
   { "token": "/mcp", "usage": "", "description": "List configured MCP servers", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/mcp add", "usage": "<name> <command> [args...]", "description": "Add an MCP server", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/mcp remove", "usage": "<name>", "description": "Remove an MCP server", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/mcp enable", "usage": "<name>", "description": "Re-enable a disabled MCP server", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/mcp disable", "usage": "<name>", "description": "Turn an MCP server off without removing it", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
-  { "token": "/mcp edit", "usage": "<name> command|args|icon <value>", "description": "Change one field of a configured MCP server", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
+  { "token": "/mcp edit", "usage": "<name> command|args|icon|timeout <value>", "description": "Change one field of a configured MCP server", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/mcp allow", "usage": "<server> <tool>", "description": "Allow an MCP tool", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/mcp disallow", "usage": "<server> <tool>", "description": "Remove a tool from a server's allowlist (* clears it)", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/mcp reauth", "usage": "<server>", "description": "Re-run a server's OAuth login (e.g. expired token)", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
@@ -77,5 +80,7 @@
   { "token": "/multi-agent", "usage": "[on|off]", "description": "Show or toggle Multi-Agent Collaboration system", "category": "system", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/avatar", "usage": "[web|desktop|status|off]", "description": "Connect agent activity to Project Avatar (real-time 3D avatar)", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/rewind", "usage": "[step]", "description": "Rewind workspace to a previous git checkpoint snapshot", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
+  { "token": "/history", "usage": "", "description": "Show saved workspace file actions and backups", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
+  { "token": "/undo", "usage": "", "description": "Undo the latest workspace file action, with conflict checks", "category": "tools", "surfaces": ["cli", "web", "desktop"] },
   { "token": "/palette", "usage": "", "description": "Open interactive command palette and action menu", "category": "system", "surfaces": ["cli", "web", "desktop"] }
 ]

package/src/bin/auto-build.js

@@ -0,0 +1,66 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawn } = require('node:child_process');
+const readline = require('node:readline');
+
+function fingerprint(root) {
+  const hash = crypto.createHash('sha256');
+  function visit(relative) {
+    const full = path.join(root, relative);
+    if (!fs.existsSync(full)) return;
+    if (fs.statSync(full).isDirectory()) {
+      for (const name of fs.readdirSync(full).sort()) {
+        if (['target', '.git', 'node_modules'].includes(name)) continue;
+        visit(path.join(relative, name));
+      }
+    } else {
+      hash.update(relative); hash.update('\0'); hash.update(fs.readFileSync(full)); hash.update('\0');
+    }
+  }
+  for (const name of ['src/bin/auto-build.js', 'Cargo.toml', 'Cargo.lock', 'rust-toolchain', 'rust-toolchain.toml', '.cargo', 'crates/mint-cli', 'crates/mint-core', 'crates/mint-companion-protocol', 'src-tauri/Cargo.toml', 'slash-commands.json', 'mcp-registry.json']) visit(name);
+  if (process.env.MINT_BUNDLE_RELEASE_NOTES === '1') visit('Release_Note.md');
+  hash.update(`MINT_BUNDLE_RELEASE_NOTES=${process.env.MINT_BUNDLE_RELEASE_NOTES === '1'}\0`);
+  for (const key of Object.keys(process.env).filter(k => /^(CARGO_|RUST|CC$|CXX$|AR$)/.test(k)).sort()) hash.update(`${key}=${process.env[key]}\0`);
+  return hash.digest('hex');
+}
+function identity(binary) {
+  const stat = fs.statSync(binary);
+  fs.accessSync(binary, process.platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
+  return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+}
+async function autoBuild(root) {
+  const stamp = path.join(root, 'target', '.mint-launcher-build.json');
+  const before = fingerprint(root);
+  try {
+    const saved = JSON.parse(fs.readFileSync(stamp, 'utf8'));
+    if (saved.fingerprint === before && saved.identity === identity(saved.binary)) return saved.binary;
+  } catch { /* No successful matching build yet. */ }
+  console.error('mint: source changed or build not verified; building latest CLI…');
+  let binary;
+  const child = spawn('cargo', ['build', '-p', 'mint-cli', '--release', '--locked', '--target-dir', path.join(root, 'target'), '--message-format=json-render-diagnostics'], { cwd: root, stdio: ['inherit', 'pipe', 'inherit'] });
+  const lines = readline.createInterface({ input: child.stdout });
+  lines.on('line', line => {
+    try {
+      const message = JSON.parse(line);
+      if (message.reason === 'compiler-artifact' && message.target?.name === 'mint' && message.executable) binary = message.executable;
+      if (message.reason === 'compiler-message' && message.message?.rendered) process.stderr.write(message.message.rendered);
+    } catch { console.error(line); }
+  });
+  await new Promise((resolve, reject) => {
+    child.once('error', reject);
+    child.once('close', (code, signal) => {
+      if (code === 0) resolve();
+      else reject(Object.assign(new Error(`build failed${signal ? ` (${signal})` : ''}; latest CLI was not launched`), { exitCode: code || 1 }));
+    });
+  });
+  if (fingerprint(root) !== before) throw new Error('source changed during build; run mint again to build latest CLI');
+  if (!binary) throw new Error('build produced no mint executable; CLI was not launched');
+  const state = { fingerprint: before, binary, identity: identity(binary) };
+  fs.mkdirSync(path.dirname(stamp), { recursive: true });
+  const temp = `${stamp}.${process.pid}.tmp`;
+  fs.writeFileSync(temp, JSON.stringify(state));
+  fs.renameSync(temp, stamp);
+  return binary;
+}
+module.exports = { autoBuild };

package/src/bin/desktop.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawn } = require('node:child_process');
+const root = path.resolve(__dirname, '../..');
+const target = path.join(root, 'target');
+const stamp = path.join(target, '.mint-desktop-build.json');
+const executable = process.platform === 'win32' ? 'mint-desktop.exe' : 'mint-desktop';
+
+function digest(inputs) {
+  const hash = crypto.createHash('sha256');
+  function visit(relative) {
+    const full = path.join(root, relative);
+    if (!fs.existsSync(full)) return;
+    if (fs.statSync(full).isDirectory()) {
+      for (const name of fs.readdirSync(full).sort()) {
+        // Tauri rewrites schemas while building; they are outputs, not inputs.
+        if (['target', '.git', 'node_modules'].includes(name) || relative === 'src-tauri' && name === 'gen') continue;
+        visit(path.join(relative, name));
+      }
+    } else {
+      hash.update(relative); hash.update('\0'); hash.update(fs.readFileSync(full)); hash.update('\0');
+    }
+  }
+  inputs.forEach(visit);
+  return hash.digest('hex');
+}
+function fingerprint(bundle = false) {
+  const source = digest(['src/bin/desktop.js', 'src-tauri', 'crates/mint-core', 'crates/mint-companion-protocol', 'src/renderer', 'public', 'Cargo.toml', 'Cargo.lock', 'rust-toolchain', 'rust-toolchain.toml', '.cargo', 'package.json', 'package-lock.json', 'vite.config.ts', 'tsconfig.json', 'tsconfig.node.json', '.env', '.env.local', '.env.production', '.env.production.local', 'slash-commands.json', 'mcp-registry.json', ...(bundle || process.env.MINT_BUNDLE_RELEASE_NOTES === '1' ? ['Release_Note.md'] : [])]);
+  const env = Object.keys(process.env).filter(k => /^(MINT_BUNDLE_RELEASE_NOTES$|CARGO_|RUST|VITE_|TAURI_|CC$|CXX$|AR$)/.test(k)).sort().map(k => [k, process.env[k]]);
+  return crypto.createHash('sha256').update(source).update(JSON.stringify(env)).digest('hex');
+}
+function identity(binary) {
+  fs.accessSync(binary, process.platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
+  const stat = fs.statSync(binary);
+  return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+}
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: 'inherit', ...options });
+    child.once('error', reject);
+    child.once('close', (code, signal) => {
+      if (code === 0) resolve();
+      else reject(Object.assign(new Error(`${path.basename(command)} failed${signal ? ` (${signal})` : ''}`), { exitCode: code || 1 }));
+    });
+  });
+}
+async function build({ fast = false, bundle = false, args = [] } = {}) {
+  const before = fingerprint(bundle);
+  const debug = args.includes('--debug');
+  const custom = args.some(arg => arg !== '--no-bundle');
+  if (custom && !debug) fs.rmSync(stamp, { force: true });
+  // Custom output targets must never accidentally validate an older host binary.
+  if (process.env.CARGO_BUILD_TARGET || args.some(a => a === '--target' || a.startsWith('--target='))) throw new Error('custom build targets are not supported by this Desktop launcher');
+  const binary = path.join(target, debug ? 'debug' : 'release', executable);
+  const env = { ...process.env, CARGO_TARGET_DIR: target, ...(bundle ? { MINT_BUNDLE_RELEASE_NOTES: '1' } : {}) };
+  if (fast) Object.assign(env, { CARGO_PROFILE_RELEASE_LTO: 'false', CARGO_PROFILE_RELEASE_CODEGEN_UNITS: '8' });
+  console.error(`mint: building ${fast ? 'fast' : 'full'} Desktop${bundle ? ' package' : ''}…`);
+  const tauri = path.join(root, 'node_modules/@tauri-apps/cli/tauri.js');
+  await run(process.execPath, [tauri, 'build', ...(bundle ? [] : ['--no-bundle']), ...args, '--', '--locked'], { cwd: root, env });
+  if (fingerprint(bundle) !== before) throw new Error('source changed during build; run the command again');
+  const state = { fingerprint: before, binary, identity: identity(binary), mode: fast ? 'fast' : 'full', assets: digest(['out/renderer']) };
+  if (!debug && !custom && !bundle) {
+    fs.mkdirSync(target, { recursive: true });
+    const temporary = `${stamp}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, JSON.stringify(state)); fs.renameSync(temporary, stamp);
+  }
+  return binary;
+}
+async function start(args) {
+  const force = args.includes('--rebuild');
+  const full = args.includes('--release');
+  const appArgs = args.filter(arg => !['--rebuild', '--release'].includes(arg));
+  let binary;
+  if (!force) {
+    try {
+      const state = JSON.parse(fs.readFileSync(stamp, 'utf8'));
+      if (state.fingerprint === fingerprint() && state.identity === identity(state.binary) && state.assets === digest(['out/renderer']) && (!full || state.mode === 'full')) binary = state.binary;
+    } catch { /* Missing or invalid success receipt requires a build. */ }
+  }
+  if (!binary) binary = await build({ fast: !full });
+  await run(binary, appArgs);
+}
+async function packageDesktop(args) {
+  const binary = await build({ bundle: true, args });
+  // Keep Tauri's native Windows/macOS installers; Linux also gets a portable tarball.
+  if (process.platform !== 'linux' || args.includes('--no-bundle')) return;
+  const output = path.dirname(binary);
+  const portable = path.join(output, 'mint-desktop-portable');
+  fs.mkdirSync(portable, { recursive: true });
+  fs.copyFileSync(binary, path.join(portable, executable));
+  const tarDir = path.join(output, 'bundle/tar');
+  fs.mkdirSync(tarDir, { recursive: true });
+  try {
+    await run('tar', ['-czf', path.join(tarDir, 'mint-agent.tar.gz'), '-C', output, 'mint-desktop-portable'], { cwd: root });
+  } finally { fs.rmSync(portable, { recursive: true, force: true }); }
+  const debDir = path.join(output, 'bundle/deb');
+  const installers = fs.readdirSync(debDir).filter(name => /^Mint_.*_amd64\.deb$/.test(name));
+  if (installers.length !== 1) throw new Error('expected one Linux amd64 installer from Tauri');
+  fs.renameSync(path.join(debDir, installers[0]), path.join(debDir, 'mint-agent_amd64.deb'));
+}
+async function main() {
+  const [command = 'start', ...args] = process.argv.slice(2);
+  if (command === 'start') await start(args);
+  else if (command === 'build') await build({ fast: args.includes('--fast'), args: args.filter(a => a !== '--fast') });
+  else if (command === 'package') await packageDesktop(args);
+  else throw new Error(`unknown Desktop command: ${command}`);
+}
+main().catch(error => {
+  console.error(`mint: ${error.message}`);
+  process.exitCode = error.exitCode || 1;
+});

package/src/bin/desktop.test.js

@@ -0,0 +1,113 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+function fixture(t) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-desktop-launch-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  for (const dir of ['src/bin', 'src/renderer', 'src-tauri/src', 'crates/mint-core/src', 'node_modules/@tauri-apps/cli', 'caller']) fs.mkdirSync(path.join(root, dir), { recursive: true });
+  for (const name of fs.readdirSync(__dirname).filter(n => n.endsWith('.js') && !n.endsWith('.test.js'))) fs.copyFileSync(path.join(__dirname, name), path.join(root, 'src/bin', name));
+  fs.writeFileSync(path.join(root, 'src/renderer/app.tsx'), 'first');
+  fs.writeFileSync(path.join(root, 'src-tauri/src/main.rs'), 'first');
+  const binary = path.join(root, 'target/release/mint-desktop');
+  const app = '#!/usr/bin/env node\nconsole.log(JSON.stringify({args:process.argv.slice(2),cwd:process.cwd()}));process.exit(Number(process.env.APP_EXIT||0));\n';
+  fs.mkdirSync(path.dirname(binary), { recursive: true });
+  fs.writeFileSync(binary, app, { mode: 0o755 });
+  fs.writeFileSync(path.join(root, 'node_modules/@tauri-apps/cli/tauri.js'), `
+const fs=require('fs');
+fs.appendFileSync(${JSON.stringify(path.join(root, 'builds'))},JSON.stringify({cwd:process.cwd(),args:process.argv.slice(2),lto:process.env.CARGO_PROFILE_RELEASE_LTO,bundleNotes:process.env.MINT_BUNDLE_RELEASE_NOTES})+'\\n');
+if(process.env.FAIL_BUILD){console.error('desktop compiler error');process.exit(19);}
+fs.writeFileSync(${JSON.stringify(binary)},${JSON.stringify(app)},{mode:0o755});
+fs.mkdirSync('out/renderer',{recursive:true});fs.writeFileSync('out/renderer/index.html','built UI');
+fs.mkdirSync('src-tauri/gen/schemas',{recursive:true});fs.writeFileSync('src-tauri/gen/schemas/generated.json',String(Date.now()));
+if(!process.argv.includes('--no-bundle')) {fs.mkdirSync('target/release/bundle/deb',{recursive:true});fs.writeFileSync('target/release/bundle/deb/Mint_1.16.0_amd64.deb','installer');}
+if(process.env.EDIT_DURING_BUILD)fs.appendFileSync('src/renderer/app.tsx','edit');
+`);
+  return {
+    root, binary,
+    run(command = 'start', args = [], extra = {}) {
+      return spawnSync(process.execPath, [path.join(root, 'src/bin/desktop.js'), command, ...args], { cwd: path.join(root, 'caller'), encoding: 'utf8', env: { ...process.env, MINT_BUNDLE_RELEASE_NOTES: '0', ...extra } });
+    },
+    builds() { return fs.existsSync(path.join(root, 'builds')) ? fs.readFileSync(path.join(root, 'builds'), 'utf8').trim().split('\n').map(JSON.parse) : []; }
+  };
+}
+
+test('start verifies existing desktop, skips unchanged build and rebuilds UI and Rust changes', t => {
+  const f = fixture(t); let result = f.run('start', ['a b', '$(echo unsafe)']);
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(f.builds().length, 1);
+  assert.deepEqual(JSON.parse(result.stdout), { args: ['a b', '$(echo unsafe)'], cwd: path.join(f.root, 'caller') });
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 1);
+  for (const file of ['src/renderer/app.tsx', 'src-tauri/src/main.rs', 'crates/mint-core/src/lib.rs', 'package-lock.json']) {
+    fs.writeFileSync(path.join(f.root, file), 'changed');
+    assert.equal(f.run().status, 0);
+  }
+  assert.equal(f.builds().length, 5);
+  fs.unlinkSync(f.binary); assert.equal(f.run().status, 0); assert.equal(f.builds().length, 6);
+});
+
+test('failed desktop build stops before opening old binary and retries', t => {
+  const f = fixture(t); const result = f.run('start', [], { FAIL_BUILD: '1' });
+  assert.equal(result.status, 19); assert.equal(result.stdout, ''); assert.match(result.stderr, /desktop compiler error/);
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 2);
+});
+
+test('full build does not launch and next start reuses it; rebuild and release options work', t => {
+  const f = fixture(t); const built = f.run('build');
+  assert.equal(built.status, 0); assert.equal(built.stdout, '');
+  assert.deepEqual(f.builds()[0].args, ['build', '--no-bundle', '--', '--locked']);
+  assert.equal(f.builds()[0].lto, undefined);
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 1);
+  assert.equal(f.run('start', ['--rebuild']).status, 0); assert.equal(f.builds().length, 2);
+  assert.equal(f.builds()[1].lto, 'false');
+  assert.equal(f.run('start', ['--release']).status, 0); assert.equal(f.builds().length, 3);
+  assert.equal(f.run('start', ['--release'], { APP_EXIT: '7' }).status, 7);
+});
+
+test('changes during desktop build stop launch without claiming the build is current', t => {
+  const f = fixture(t); const result = f.run('start', [], { EDIT_DURING_BUILD: '1' });
+  assert.notEqual(result.status, 0); assert.equal(result.stdout, ''); assert.match(result.stderr, /changed during build/);
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 2);
+});
+
+
+test('package produces the installer and a portable archive without launching desktop', t => {
+  const f = fixture(t); const result = f.run('package');
+  assert.equal(result.status, 0, result.stderr); assert.equal(result.stdout, '');
+  assert.equal(fs.readFileSync(path.join(f.root, 'target/release/bundle/deb/mint-agent_amd64.deb'), 'utf8'), 'installer');
+  const archive = path.join(f.root, 'target/release/bundle/tar/mint-agent.tar.gz');
+  const listing = spawnSync('tar', ['-tzf', archive], { encoding: 'utf8' });
+  assert.equal(listing.status, 0, listing.stderr); assert.match(listing.stdout, /mint-desktop-portable\/mint-desktop/);
+  assert.equal(f.builds()[0].bundleNotes, '1');
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 2);
+});
+
+test('custom Desktop build cannot validate the default start cache', t => {
+  const f = fixture(t);
+  assert.equal(f.run('build', ['--config', '{"app":{"windows":[]}}']).status, 0);
+  assert.equal(f.run().status, 0);
+  assert.equal(f.builds().length, 2);
+});
+
+test('protocol source edits invalidate a cached Desktop build', t => {
+  const f = fixture(t);
+  const protocol = path.join(f.root, 'crates/mint-companion-protocol/src');
+  fs.mkdirSync(protocol, { recursive: true });
+  fs.writeFileSync(path.join(protocol, 'lib.rs'), 'v1');
+  assert.equal(f.run().status, 0);
+  fs.writeFileSync(path.join(protocol, 'lib.rs'), 'v2');
+  assert.equal(f.run().status, 0);
+  assert.equal(f.builds().length, 2);
+});
+
+test('release note edits do not rebuild a development Desktop', t => {
+  const f = fixture(t);
+  fs.writeFileSync(path.join(f.root, 'Release_Note.md'), 'first notes');
+  assert.equal(f.run().status, 0);
+  fs.writeFileSync(path.join(f.root, 'Release_Note.md'), 'updated notes');
+  assert.equal(f.run().status, 0);
+  assert.equal(f.builds().length, 1);
+});

package/src/bin/index.js

@@ -35,7 +35,7 @@ function findBinary() {
 
   for (const candidate of candidates) {
     try {
-      if (fs.existsSync(candidate)) {
+      if (fs.existsSync(candidate) && fs.realpathSync(candidate) !== fs.realpathSync(__filename)) {
         if (process.platform !== 'win32') {
           fs.accessSync(candidate, fs.constants.X_OK);
         }
@@ -49,29 +49,22 @@ function findBinary() {
   return null;
 }
 
-const binaryPath = findBinary();
-
-if (!binaryPath) {
-  console.error(
-    `\x1b[31mmint: native binary not found.\x1b[0m\n\n` +
-    `Build or install the binary with:\n` +
-    `  \x1b[32mcargo build -p mint-cli\x1b[0m              (fast debug build)\n` +
-    `  \x1b[32mcargo build -p mint-cli --release\x1b[0m    (optimized release build)\n` +
-    `  \x1b[32mcargo install --path crates/mint-cli\x1b[0m   (install permanently to ~/.cargo/bin)\n`
-  );
-  process.exit(1);
+async function main() {
+  const root = path.resolve(__dirname, '../..');
+  const sourceCheckout = fs.existsSync(path.join(root, '.git')) && fs.existsSync(path.join(root, 'crates/mint-cli/src/main.rs'));
+  // Explicit overrides and distributed packages keep their existing launch behavior.
+  const binaryPath = !process.env.MINT_BIN && sourceCheckout
+    ? await require('./auto-build').autoBuild(root)
+    : findBinary();
+  if (!binaryPath) throw new Error('native binary not found; run npm run build:cli first');
+  const child = spawn(binaryPath, process.argv.slice(2), { stdio: 'inherit' });
+  child.once('error', err => { console.error(`mint: ${err.message}`); process.exitCode = 1; });
+  child.once('close', (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    else process.exitCode = code ?? 1;
+  });
 }
-
-// Forward every argument straight through to the Rust binary.
-const child = spawn(binaryPath, process.argv.slice(2), {
-  stdio: 'inherit'
-});
-
-child.on('error', (err) => {
-  console.error(`\x1b[31mmint: failed to spawn binary at ${binaryPath}:\x1b[0m`, err.message);
-  process.exit(1);
-});
-
-child.on('close', (code) => {
-  process.exit(code ?? 0);
+main().catch(err => {
+  console.error(`mint: ${err.message}`);
+  process.exitCode = err.exitCode || 1;
 });

package/src/bin/index.test.js

@@ -0,0 +1,89 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+function fixture(t) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-auto-build-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  for (const dir of ['src/bin', 'crates/mint-cli/src', 'crates/mint-core/src', '.git', 'tools', 'caller']) fs.mkdirSync(path.join(root, dir), { recursive: true });
+  for (const name of fs.readdirSync(__dirname).filter(n => n.endsWith('.js') && !n.endsWith('.test.js'))) fs.copyFileSync(path.join(__dirname, name), path.join(root, 'src/bin', name));
+  fs.writeFileSync(path.join(root, 'Cargo.toml'), '[workspace]\n');
+  fs.writeFileSync(path.join(root, 'crates/mint-cli/src/main.rs'), 'first');
+  const binary = path.join(root, 'target/release/mint');
+  const body = '#!/usr/bin/env node\nconsole.log(JSON.stringify({args:process.argv.slice(2),cwd:process.cwd(),version:"fresh"}));\n';
+  fs.writeFileSync(path.join(root, 'tools/cargo'), `#!/usr/bin/env node
+const fs=require('fs'); const path=require('path');
+fs.appendFileSync(${JSON.stringify(path.join(root, 'builds'))}, process.cwd()+'\\n');
+if(process.env.FAIL_BUILD) {console.error('compiler test error');process.exit(17);}
+fs.mkdirSync(${JSON.stringify(path.dirname(binary))},{recursive:true});
+fs.writeFileSync(${JSON.stringify(binary)},${JSON.stringify(body)},{mode:0o755});
+console.log(JSON.stringify({reason:'compiler-artifact',target:{name:'mint',kind:['bin']},executable:${JSON.stringify(binary)}}));
+if(process.env.EDIT_DURING_BUILD) fs.appendFileSync(${JSON.stringify(path.join(root, 'crates/mint-cli/src/main.rs'))},'changed');
+`, { mode: 0o755 });
+  const run = (extra = {}) => {
+    const env = { ...process.env, MINT_BUNDLE_RELEASE_NOTES: '0', PATH: path.join(root, 'tools') + path.delimiter + process.env.PATH, ...extra };
+    delete env.MINT_BIN;
+    return spawnSync(process.execPath, [path.join(root, 'src/bin/index.js'), '--test', 'a b', '$(echo unexpected)'], { cwd: path.join(root, 'caller'), env, encoding: 'utf8' });
+  };
+  const builds = () => fs.existsSync(path.join(root, 'builds')) ? fs.readFileSync(path.join(root, 'builds'), 'utf8').trim().split('\n') : [];
+  return { root, run, builds, binary };
+}
+
+test('builds first launch, preserves caller cwd and arguments, skips unchanged launch', t => {
+  const f = fixture(t); const first = f.run();
+  assert.equal(first.status, 0, first.stderr);
+  assert.deepEqual(JSON.parse(first.stdout), { args: ['--test', 'a b', '$(echo unexpected)'], cwd: path.join(f.root, 'caller'), version: 'fresh' });
+  assert.deepEqual(f.builds(), [f.root]);
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 1);
+  fs.writeFileSync(path.join(f.root, 'crates/mint-cli/src/main.rs'), 'second');
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 2);
+  fs.writeFileSync(path.join(f.root, 'mcp-registry.json'), '{}');
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 3);
+  fs.unlinkSync(path.join(f.root, 'mcp-registry.json'));
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 4);
+  fs.unlinkSync(f.binary);
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 5);
+});
+
+test('failed rebuild shows compiler error, never launches old binary and retries next launch', t => {
+  const f = fixture(t); assert.equal(f.run().status, 0);
+  fs.writeFileSync(path.join(f.root, 'crates/mint-cli/src/main.rs'), 'changed');
+  const failed = f.run({ FAIL_BUILD: '1' });
+  assert.equal(failed.status, 17); assert.equal(failed.stdout, ''); assert.match(failed.stderr, /compiler test error/);
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 3);
+});
+
+test('source edits during build do not launch or mark the build current', t => {
+  const f = fixture(t); const result = f.run({ EDIT_DURING_BUILD: '1' });
+  assert.notEqual(result.status, 0); assert.equal(result.stdout, '');
+  assert.match(result.stderr, /changed during build/);
+  assert.equal(f.run().status, 0); assert.equal(f.builds().length, 2);
+});
+
+test('protocol source edits rebuild the CLI before connecting Companion', t => {
+  const f = fixture(t);
+  const protocol = path.join(f.root, 'crates/mint-companion-protocol/src');
+  fs.mkdirSync(protocol, { recursive: true });
+  fs.writeFileSync(path.join(protocol, 'lib.rs'), 'v1');
+  assert.equal(f.run().status, 0);
+  fs.writeFileSync(path.join(protocol, 'lib.rs'), 'v2');
+  assert.equal(f.run().status, 0);
+  assert.equal(f.builds().length, 2);
+});
+
+test('development release note edits do not rebuild the CLI but bundled builds track them', t => {
+  const f = fixture(t);
+  const notes = path.join(f.root, 'Release_Note.md');
+  fs.writeFileSync(notes, 'first notes');
+  assert.equal(f.run().status, 0);
+  fs.writeFileSync(notes, 'updated notes');
+  assert.equal(f.run().status, 0);
+  assert.equal(f.builds().length, 1);
+  assert.equal(f.run({ MINT_BUNDLE_RELEASE_NOTES: '1' }).status, 0);
+  fs.writeFileSync(notes, 'packaged notes');
+  assert.equal(f.run({ MINT_BUNDLE_RELEASE_NOTES: '1' }).status, 0);
+  assert.equal(f.builds().length, 3);
+});