gm-skill 2.0.1302 → 2.0.1319

package/gm-plugkit/plugkit-wasm-wrapper.js

@@ -381,7 +381,18 @@ function emitOrchestratorEvents(verb, taskBase, resultStr) {
     if (verb === 'prd-resolve' && errData && errData.deviation_kind === 'prd-resolve-unknown-id') {
       logEvent('hook', 'deviation.prd-resolve-unknown-id', { task: taskBase, prd_id: errData.prd_id, reason: errData.error });
     }
-    logEvent('plugkit', 'orchestrator.error', { verb, task: taskBase, error: parsed && parsed.error ? String(parsed.error) : 'unknown' });
+    const reason = (parsed && (parsed.reason || parsed.error)) ||
+                   (parsed && parsed.data && (parsed.data.reason || parsed.data.error)) ||
+                   (errData && (errData.reason || errData.error)) ||
+                   (parsed && parsed.stderr) ||
+                   'unknown';
+    logEvent('plugkit', 'orchestrator.error', {
+      verb,
+      task: taskBase,
+      error: String(reason).slice(0, 500),
+      gate_denied: !!(parsed && parsed.gate_denied),
+      next_dispatch: parsed && parsed.next_dispatch || null,
+    });
     return;
   }
   const data = parsed.data || {};
@@ -722,105 +733,133 @@ function findInstalledChromiumBinary() {
   }
 }
 
+function fetchJsonSync(url, timeoutMs) {
+  const r = spawnSync(process.execPath, ['-e', `
+    const http = require('http');
+    const req = http.get(${JSON.stringify(url)}, (res) => {
+      let buf = '';
+      res.on('data', d => buf += d);
+      res.on('end', () => {
+        if (res.statusCode !== 200) { process.stderr.write('status ' + res.statusCode); process.exit(2); }
+        process.stdout.write(buf);
+      });
+    });
+    req.on('error', e => { process.stderr.write(e.message); process.exit(1); });
+    req.setTimeout(${timeoutMs || 1500}, () => { req.destroy(new Error('timeout')); });
+  `], { encoding: 'utf-8', timeout: (timeoutMs || 1500) + 1500, windowsHide: true });
+  if (r.status !== 0) return null;
+  try { return JSON.parse(r.stdout); } catch (_) { return null; }
+}
+
 function startManagedBrowser(pw, profileDir) {
   const headless = process.env.GM_BROWSER_HEADLESS === '1';
-  const args = [...pw.baseArgs, 'browser', 'start', '--user-data-dir', profileDir];
-  if (headless) args.push('--headless');
-  const env = { ...process.env };
-  if (!env.GM_BROWSER_RUNNER_PATH && !env.PLAYWRITER_BROWSER_PATH) {
-    const browserBin = findInstalledChromiumBinary();
-    if (browserBin) {
-      env.GM_BROWSER_RUNNER_PATH = browserBin;
-      env.PLAYWRITER_BROWSER_PATH = browserBin;
-      logEvent('plugkit', 'browser.binary-resolved', { path: browserBin });
-    } else {
-      logEvent('plugkit', 'browser.binary-missing', {});
-    }
+  let browserBin = findInstalledChromiumBinary();
+  if (!browserBin) {
+    logEvent('plugkit', 'browser.chromium-installing', {});
+    spawnSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['--yes', 'playwright', 'install', 'chromium'], {
+      encoding: 'utf-8',
+      timeout: 300000,
+      windowsHide: true,
+      shell: process.platform === 'win32',
+      stdio: 'ignore',
+    });
+    browserBin = findInstalledChromiumBinary();
+  }
+  if (!browserBin) {
+    const err = new Error('chromium binary not found after install attempt');
+    logEvent('plugkit', 'browser.launch-failed', { reason: 'chromium-missing' });
+    throw err;
   }
-  const child = spawn(pw.cmd, args, {
+  const port = findFreePortSync();
+  const args = [
+    '--user-data-dir=' + profileDir,
+    '--remote-debugging-port=' + port,
+    '--remote-debugging-address=127.0.0.1',
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--disable-default-apps',
+  ];
+  if (headless) args.push('--headless=new');
+  const chromeLogPath = path.join(profileDir, '.chrome-launch.log');
+  let logFd;
+  try { logFd = fs.openSync(chromeLogPath, 'a'); } catch (_) { logFd = null; }
+  const child = spawn(browserBin, args, {
     detached: true,
-    stdio: 'ignore',
-    shell: pw.shell,
-    windowsHide: true,
-    env,
-    ...(process.platform === 'win32' ? { creationFlags: 0x08000000 | 0x00000008 } : {}),
+    stdio: ['ignore', logFd != null ? logFd : 'ignore', logFd != null ? logFd : 'ignore'],
+    windowsHide: false,
+    env: process.env,
   });
+  try { if (typeof logFd === 'number') fs.closeSync(logFd); } catch (_) {}
   const pid = child.pid;
   child.unref();
-  return pid;
+  logEvent('plugkit', 'browser.chromium-launched', { pid, port, profileDir, headless, binary: browserBin, chromeLogPath });
+  const start = Date.now();
+  const deadline = start + 30000;
+  let wsEndpoint = null;
+  let lastErr = null;
+  while (Date.now() < deadline) {
+    const info = fetchJsonSync(`http://127.0.0.1:${port}/json/version`, 1500);
+    if (info && info.webSocketDebuggerUrl) {
+      wsEndpoint = info.webSocketDebuggerUrl;
+      break;
+    }
+    sleepSync(500);
+  }
+  if (!wsEndpoint) {
+    logEvent('plugkit', 'browser.launch-failed', { reason: 'cdp-not-ready', pid, port, elapsed_ms: Date.now() - start });
+    throw new Error(`chromium launched (pid=${pid}) but CDP at 127.0.0.1:${port} did not become ready within 30s${lastErr ? ' :: ' + lastErr : ''}`);
+  }
+  logEvent('plugkit', 'browser.cdp-ready', { pid, port, ms: Date.now() - start, wsEndpoint });
+  return { pid, port, wsEndpoint };
 }
 
-function isColdRunProfile(profileDir) {
-  try {
-    if (!fs.existsSync(profileDir)) return true;
-    const entries = fs.readdirSync(profileDir);
-    if (entries.length === 0) return true;
-    if (!entries.some(n => n === 'Default' || n === 'Local State')) return true;
-    return false;
-  } catch (_) {
-    return true;
+function killPidQuiet(pid) {
+  if (!Number.isFinite(pid) || pid <= 0 || pid === process.pid) return false;
+  try { process.kill(pid, 'SIGTERM'); } catch (_) {}
+  if (process.platform === 'win32') {
+    try { spawnSync('taskkill', ['/F', '/T', '/PID', String(pid)], { stdio: 'ignore', timeout: 3000 }); } catch (_) {}
   }
+  return true;
 }
 
-function resolveManagedBrowserKey(pw) {
-  const explicitKey = process.env.GM_BROWSER_RUNNER_KEY || process.env.PLAYWRITER_BROWSER_KEY;
-  if (explicitKey) {
-    if (/^profile:/.test(explicitKey)) {
-      throw new Error(`GM_BROWSER_RUNNER_KEY=${explicitKey} points at a user OS browser profile; refusing — managed sessions must use install:Chromium:*`);
-    }
-    return explicitKey;
-  }
-  let text = '';
-  try {
-    const r = runBrowserRunner(pw, ['browser', 'list'], 8000);
-    text = (r && (r.stdout || r.stderr)) || '';
-  } catch (e) {
-    throw new Error(`managed browser session list failed: ${e.message}`);
+function purgeProfileLockFiles(profileDir) {
+  if (!profileDir) return;
+  for (const name of ['SingletonLock', 'SingletonCookie', 'SingletonSocket']) {
+    try { fs.unlinkSync(path.join(profileDir, name)); } catch (_) {}
   }
-  const lines = text.split(/\r?\n/);
-  const installChromium = lines.map(l => (l.match(/\b(install:Chromium:[A-Za-z0-9_-]+)\b/) || [])[1]).find(Boolean);
-  if (installChromium) return installChromium;
-  throw new Error(`no managed Chromium install detected; browser runner returned: ${scrubBrowserRunnerText(text).trim()}`);
 }
 
-function waitForExtensionReady(pw, profileDir, opts) {
-  const cold = (opts && typeof opts.cold === 'boolean') ? opts.cold : isColdRunProfile(profileDir);
-  const timeoutMs = (opts && opts.timeoutMs) || (cold ? 180000 : 30000);
-  const start = Date.now();
-  const deadline = start + timeoutMs;
-  const backoff = [2000, 4000, 8000];
-  let attempt = 0;
-  let lastErr = '';
-  let lastProgressAt = start;
-  const browserKey = resolveManagedBrowserKey(pw);
-  while (Date.now() < deadline) {
-    const remaining = deadline - Date.now();
-    const innerTimeout = Math.max(28000, Math.min(remaining, 30000));
-    const r = runBrowserRunner(pw, ['session', 'new', '--browser', browserKey], innerTimeout);
-    if (r && r.status === 0) return r;
-    lastErr = scrubBrowserRunnerText((r && (r.stderr || r.stdout)) || '');
-    const now = Date.now();
-    if (now - lastProgressAt >= 10000) {
-      logEvent('plugkit', 'browser.extension-wait', {
-        elapsed_ms: now - start,
-        cold_run: cold,
-        profileDir,
-        attempt,
-      });
-      lastProgressAt = now;
-    }
-    const sleepMs = backoff[Math.min(attempt, backoff.length - 1)];
-    attempt++;
-    if (Date.now() + sleepMs >= deadline) break;
-    sleepSync(sleepMs);
+function sleepSyncMs(ms) {
+  if (ms <= 0) return;
+  spawnSync(process.execPath, ['-e', `setTimeout(()=>process.exit(0),${ms})`], { timeout: ms + 500, windowsHide: true });
+}
+
+function gracefulCloseBrowser(entry, reason) {
+  if (!entry) return;
+  const { pid, port, profileDir } = entry;
+  if (Number.isFinite(port) && port > 0) {
+    try {
+      const info = fetchJsonSync(`http://127.0.0.1:${port}/json/version`, 600);
+      if (info && info.webSocketDebuggerUrl) {
+        spawnSync(process.execPath, ['-e', `
+          const http = require('http');
+          const req = http.request({host:'127.0.0.1',port:${port},path:'/json/close/browser',method:'GET',timeout:1500},
+            res => { res.resume(); res.on('end', () => process.exit(0)); });
+          req.on('error', () => process.exit(1));
+          req.on('timeout', () => { req.destroy(); process.exit(1); });
+          req.end();
+        `], { timeout: 3000, windowsHide: true });
+      }
+    } catch (_) {}
+  }
+  if (Number.isFinite(pid) && pid > 0) {
+    const deadline = Date.now() + 1500;
+    try { process.kill(pid, 'SIGTERM'); } catch (_) {}
+    while (Date.now() < deadline && isProcessAliveSync(pid)) sleepSyncMs(Math.min(150, deadline - Date.now()));
+    if (isProcessAliveSync(pid)) killPidQuiet(pid);
   }
-  const flavor = cold
-    ? `cold-run timeout after ${Math.round((Date.now() - start) / 1000)}s waiting for managed browser extension to connect (first run downloads chromium ~150MB and installs the extension; if this persists the extension never registered with the relay server)`
-    : `warm-run timeout after ${Math.round((Date.now() - start) / 1000)}s waiting for managed browser extension to reconnect (profile exists but extension is not registering; relay server may be wedged)`;
-  const err = new Error(`managed browser session start failed: ${flavor}${lastErr ? ` :: ${lastErr}` : ''}`);
-  err._lastErr = lastErr;
-  err._coldRun = cold;
-  throw err;
+  purgeProfileLockFiles(profileDir);
+  try { logEvent('plugkit', 'browser.closed', { reason: reason || 'closed', pid, port, profileDir }); } catch (_) {}
 }
 
 function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
@@ -830,15 +869,29 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
   const ports = readJsonFile(portsFile, {});
   const sessions = readJsonFile(sessionsFile, {});
   const existing = ports[claudeSessionId];
-  if (existing && existing.pid) {
+  if (existing && existing.pid && existing.wsEndpoint) {
     const wantProfile = path.join(cwd, '.gm', 'browser-profile');
     const pidOk = isProcessAliveSync(existing.pid);
     const profileOk = !existing.profileDir || existing.profileDir === wantProfile || existing.profileDir.startsWith(path.join(cwd, '.gm', 'browser-profile'));
-    if (pidOk && profileOk) {
+    const cdpOk = pidOk && !!fetchJsonSync(`http://127.0.0.1:${existing.port}/json/version`, 1000);
+    if (pidOk && profileOk && cdpOk) {
       const pwIds = sessions[claudeSessionId] || [];
-      if (pwIds.length > 0) return pwIds[0];
+      if (pwIds.length > 0 && existing.pwSessionId) return existing.pwSessionId;
+      const r = runBrowserRunner(pw, ['session', 'new', '--direct', existing.wsEndpoint], 30000);
+      if (r && r.status === 0) {
+        const sid = parseSessionId(r.stdout || '');
+        if (sid) {
+          existing.pwSessionId = sid;
+          ports[claudeSessionId] = existing;
+          sessions[claudeSessionId] = [sid];
+          writeJsonFile(portsFile, ports);
+          writeJsonFile(sessionsFile, sessions);
+          logEvent('plugkit', 'browser.attached', { pwSessionId: sid, reused: true });
+          return sid;
+        }
+      }
     } else {
-      const reason = !pidOk ? 'pid-dead' : 'profile-drift';
+      const reason = !pidOk ? 'pid-dead' : (!cdpOk ? 'cdp-dead' : 'profile-drift');
       logEvent('hook', 'deviation.browser-profile-collision', {
         sid: claudeSessionId,
         stale_pid: existing.pid || null,
@@ -846,6 +899,12 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
         want_profile: wantProfile,
         reason,
       });
+      if (typeof gracefulCloseBrowser === 'function') {
+        try { gracefulCloseBrowser(existing, `collision:${reason}`); } catch (_) {}
+      } else if (pidOk && Number.isFinite(existing.pid)) {
+        try { killPidQuiet(existing.pid); } catch (_) {}
+      }
+      purgeProfileLockFiles(existing.profileDir);
       delete ports[claudeSessionId];
       delete sessions[claudeSessionId];
       try { writeJsonFile(portsFile, ports); } catch (_) {}
@@ -853,32 +912,58 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
     }
   }
   cleanDeadProfileFragments(cwd);
-  const probedProfile = path.join(cwd, '.gm', 'browser-profile');
-  const coldRun = isColdRunProfile(probedProfile);
   const profileDir = acquireProfileDir(cwd);
-  logEvent('plugkit', 'browser.start', { profileDir, cold_run: coldRun });
-  const browserPid = startManagedBrowser(pw, profileDir);
-  const newR = waitForExtensionReady(pw, profileDir, { cold: coldRun });
-  const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
-  const out = stripAnsi(newR.stdout || '').trim();
-  let pwSessionId = null;
-  const created = out.match(/Session\s+(\S+)\s+created/i);
-  if (created) pwSessionId = created[1];
-  if (!pwSessionId) {
-    const hex = out.match(/\b([a-f0-9-]{8,})\b/i);
-    if (hex) pwSessionId = hex[1];
+  const aliveCdpForProfile = (() => {
+    for (const key of Object.keys(ports)) {
+      const ent = ports[key];
+      if (!ent || !ent.pid || !ent.port || !ent.wsEndpoint) continue;
+      if (ent.profileDir !== profileDir && !(ent.profileDir || '').startsWith(profileDir)) continue;
+      if (!isProcessAliveSync(ent.pid)) continue;
+      const info = fetchJsonSync(`http://127.0.0.1:${ent.port}/json/version`, 1000);
+      if (info && info.webSocketDebuggerUrl) {
+        return { pid: ent.pid, port: ent.port, wsEndpoint: ent.wsEndpoint };
+      }
+    }
+    return null;
+  })();
+  let browserPid, port, wsEndpoint;
+  if (aliveCdpForProfile) {
+    ({ pid: browserPid, port, wsEndpoint } = aliveCdpForProfile);
+    logEvent('plugkit', 'browser.reused-existing-chromium', { pid: browserPid, port, profileDir });
+  } else {
+    logEvent('plugkit', 'browser.start', { profileDir });
+    ({ pid: browserPid, port, wsEndpoint } = startManagedBrowser(pw, profileDir));
+  }
+  const r = runBrowserRunner(pw, ['session', 'new', '--direct', wsEndpoint], 30000);
+  if (!r || r.status !== 0) {
+    const errTxt = scrubBrowserRunnerText((r && (r.stderr || r.stdout)) || 'unknown');
+    logEvent('plugkit', 'browser.launch-failed', { reason: 'session-attach-failed', pid: browserPid, port, error: errTxt });
+    throw new Error(`playwriter session new --direct failed: ${errTxt}`);
   }
+  const pwSessionId = parseSessionId(r.stdout || '');
   if (!pwSessionId) {
-    try { const j = JSON.parse(out); pwSessionId = j.id || j.session_id || j.session; } catch (_) {}
+    logEvent('plugkit', 'browser.launch-failed', { reason: 'session-id-unparseable', stdout: r.stdout });
+    throw new Error(`could not parse managed browser session id from: ${scrubBrowserRunnerText(r.stdout || '')}`);
   }
-  if (!pwSessionId) throw new Error(`could not parse managed browser session id from: ${scrubBrowserRunnerText(out)}`);
-  ports[claudeSessionId] = { profileDir, pid: browserPid };
+  ports[claudeSessionId] = { profileDir, pid: browserPid, port, wsEndpoint, pwSessionId };
   sessions[claudeSessionId] = [pwSessionId];
   writeJsonFile(portsFile, ports);
   writeJsonFile(sessionsFile, sessions);
+  logEvent('plugkit', 'browser.attached', { pwSessionId, pid: browserPid, port });
   return pwSessionId;
 }
 
+function parseSessionId(rawOut) {
+  const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+  const out = stripAnsi(rawOut || '').trim();
+  const created = out.match(/Session\s+(\S+)\s+created/i);
+  if (created) return created[1];
+  const hex = out.match(/\b([a-f0-9-]{8,})\b/i);
+  if (hex) return hex[1];
+  try { const j = JSON.parse(out); return j.id || j.session_id || j.session || null; } catch (_) {}
+  return null;
+}
+
 const VEC_K_DEFAULT = 10;
 const EMBED_MODEL_DEFAULT = process.env.EMBED_MODEL || 'mistral/mistral-embed';
 const INFERENCE_MODEL_DEFAULT = process.env.INFERENCE_MODEL || 'groq/llama-3.3-70b-versatile';
@@ -1048,6 +1133,32 @@ function kvNamespaceDirs(ns) {
   return out;
 }
 
+function enabledDisciplineNamespaces(baseNs) {
+  const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const set = new Set([baseNs]);
+  try {
+    const enabledPath = path.join(projectRoot, '.gm', 'disciplines', 'enabled.txt');
+    if (fs.existsSync(enabledPath)) {
+      const lines = fs.readFileSync(enabledPath, 'utf-8').split(/\r?\n/);
+      for (const ln of lines) {
+        const name = ln.trim();
+        if (name && !name.startsWith('#')) set.add(name);
+      }
+    }
+  } catch (_) {}
+  return Array.from(set);
+}
+
+function jaccardOverlap(a, b) {
+  if (!a || !b) return 0;
+  const tokenize = (s) => new Set(String(s).toLowerCase().split(/[^a-z0-9]+/).filter(t => t.length >= 3));
+  const A = tokenize(a), B = tokenize(b);
+  if (A.size === 0 || B.size === 0) return 0;
+  let inter = 0;
+  for (const t of A) if (B.has(t)) inter++;
+  return inter / (A.size + B.size - inter);
+}
+
 const __tasks = new Map();
 
 function tasksDir(cwd) {
@@ -1379,8 +1490,8 @@ function makeHostFunctions(instanceRef) {
         if (!raw) return writeWasmJson(instanceRef.value, []);
         let parsedQ;
         try { parsedQ = JSON.parse(raw); } catch (_) { parsedQ = { query: raw }; }
-        const q = parsedQ.query || raw;
         const namespace = parsedQ.namespace || 'default';
+        const sigil = parsedQ.sigil || parsedQ.discipline_sigil || null;
         const extractVec = (e) => {
           if (Array.isArray(e)) return e;
           if (Array.isArray(e?.data?.[0]?.embedding)) return e.data[0].embedding;
@@ -1393,37 +1504,58 @@ function makeHostFunctions(instanceRef) {
           if (process.env.PLUGKIT_DEBUG) console.error('[plugkit-wasm] host_vec_search: no embedding in query, raw=', raw.slice(0, 200));
           return writeWasmJson(instanceRef.value, []);
         }
-        const vecDirs = kvNamespaceDirs(`${namespace}-vec`);
-        const dataDirs = kvNamespaceDirs(namespace);
-        if (vecDirs.length === 0 || dataDirs.length === 0) {
-          return writeWasmJson(instanceRef.value, []);
-        }
+        const namespaces = sigil ? [namespace] : enabledDisciplineNamespaces(namespace);
+        const HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1000;
+        const DEDUP_JACCARD = 0.7;
+        const RECENCY_FLOOR = 0.4;
+        const nowMs = Date.now();
         const scored = [];
         const seen = new Set();
-        for (const vecDir of vecDirs) {
-          for (const f of fs.readdirSync(vecDir)) {
-            if (!f.endsWith('.json')) continue;
-            const key = f.replace(/\.json$/, '');
-            if (seen.has(key)) continue;
-            seen.add(key);
-            let emb;
-            try { emb = JSON.parse(fs.readFileSync(path.join(vecDir, f), 'utf-8')); }
-            catch (_) { continue; }
-            const vector = Array.isArray(emb?.data?.[0]?.embedding) ? emb.data[0].embedding
-                         : Array.isArray(emb?.embedding) ? emb.embedding
-                         : Array.isArray(emb) ? emb : null;
-            if (!vector) continue;
-            const score = cosineSim(queryEmbedding, vector);
-            let text = '';
-            for (const dataDir of dataDirs) {
-              const valuePath = path.join(dataDir, `${key}.json`);
-              if (fs.existsSync(valuePath)) { text = fs.readFileSync(valuePath, 'utf-8'); break; }
+        for (const ns of namespaces) {
+          const vecDirs = kvNamespaceDirs(`${ns}-vec`);
+          const dataDirs = kvNamespaceDirs(ns);
+          if (vecDirs.length === 0 || dataDirs.length === 0) continue;
+          for (const vecDir of vecDirs) {
+            for (const f of fs.readdirSync(vecDir)) {
+              if (!f.endsWith('.json')) continue;
+              const key = f.replace(/\.json$/, '');
+              const seenKey = `${ns}::${key}`;
+              if (seen.has(seenKey)) continue;
+              seen.add(seenKey);
+              const vecPath = path.join(vecDir, f);
+              let emb, mtimeMs;
+              try {
+                emb = JSON.parse(fs.readFileSync(vecPath, 'utf-8'));
+                mtimeMs = fs.statSync(vecPath).mtimeMs;
+              } catch (_) { continue; }
+              const vector = Array.isArray(emb?.data?.[0]?.embedding) ? emb.data[0].embedding
+                           : Array.isArray(emb?.embedding) ? emb.embedding
+                           : Array.isArray(emb) ? emb : null;
+              if (!vector) continue;
+              const cos = cosineSim(queryEmbedding, vector);
+              const ageMs = Math.max(0, nowMs - mtimeMs);
+              const recency = RECENCY_FLOOR + (1 - RECENCY_FLOOR) * Math.exp(-ageMs / HALF_LIFE_MS);
+              const score = cos * recency;
+              let text = '';
+              for (const dataDir of dataDirs) {
+                const valuePath = path.join(dataDir, `${key}.json`);
+                if (fs.existsSync(valuePath)) { text = fs.readFileSync(valuePath, 'utf-8'); break; }
+              }
+              scored.push({ key, text, score, cos, recency, namespace: ns });
             }
-            scored.push({ key, text, score });
           }
         }
         scored.sort((a, b) => b.score - a.score);
-        return writeWasmJson(instanceRef.value, scored.slice(0, k_));
+        const out = [];
+        for (const hit of scored) {
+          let dup = false;
+          for (const kept of out) {
+            if (jaccardOverlap(hit.text, kept.text) >= DEDUP_JACCARD) { dup = true; break; }
+          }
+          if (!dup) out.push(hit);
+          if (out.length >= k_) break;
+        }
+        return writeWasmJson(instanceRef.value, out);
       } catch (e) {
         console.error('[plugkit-wasm] host_vec_search error:', e.message);
         return writeWasmJson(instanceRef.value, []);
@@ -1483,6 +1615,15 @@ function makeHostFunctions(instanceRef) {
         const prefix = level >= 3 ? '[plugkit-wasm:err]' : level >= 2 ? '[plugkit-wasm:warn]' : '[plugkit-wasm]';
         if (level >= 2) console.error(`${prefix} ${msg}`);
         else console.log(`${prefix} ${msg}`);
+        const evtMatch = msg.match(/^evt:\s*(\{.*\})\s*$/);
+        if (evtMatch) {
+          try {
+            const ev = JSON.parse(evtMatch[1]);
+            const eventName = ev.event || 'wasm.event';
+            const { event: _e, ts: _ts, sess: _s, sub: _sub, ...fields } = ev;
+            logEvent(ev.sub || 'plugkit', eventName, fields);
+          } catch (_) {}
+        }
         return 0;
       } catch (e) {
         return 0;
@@ -1519,6 +1660,7 @@ function makeHostFunctions(instanceRef) {
           });
         }
         const pwSessionId = getOrCreateBrowserSession(cwd, sessionId, pw);
+        try { lastBrowserActivityMs = Date.now(); } catch (_) {}
         const r = runBrowserRunner(pw, ['-s', pwSessionId, '--timeout', '14000', '-e', body], 60000);
         return writeWasmJson(instanceRef.value, {
           ok: r.status === 0,
@@ -1562,16 +1704,13 @@ function makeHostFunctions(instanceRef) {
         const args = readWasmStr(instanceRef.value, argsPtr, argsLen);
         const cwdStr = readWasmStr(instanceRef.value, cwdPtr, cwdLen);
         const cwd = cwdStr || process.cwd();
-        const { execSync } = require('child_process');
-        let stdout = '', stderr = '', exit_code = 0;
-        try {
-          stdout = execSync('git ' + args, { encoding: 'utf8', timeout: 30000, cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-        } catch (e) {
-          stdout = String((e && e.stdout) || '');
-          stderr = String((e && e.stderr) || (e && e.message) || '');
-          exit_code = (e && typeof e.status === 'number') ? e.status : 1;
-        }
-        return writeWasmJson(instanceRef.value, { stdout, stderr, exit_code });
+        const argv = args.trim().split(/\s+/);
+        const result = _rawSpawnSync('git', argv, { encoding: 'utf-8', timeout: 30000, cwd, windowsHide: true });
+        return writeWasmJson(instanceRef.value, {
+          stdout: result.stdout || '',
+          stderr: result.stderr || '',
+          exit_code: result.status === null ? -1 : result.status,
+        });
       } catch (e) {
         return writeWasmJson(instanceRef.value, { stdout: '', stderr: String(e && e.message || e), exit_code: 1 });
       }
@@ -1825,14 +1964,7 @@ async function runSpoolWatcher(instance, spoolDir) {
     lastActivityMs = Date.now();
   }
 
-  function killPidQuiet(pid) {
-    if (!Number.isFinite(pid) || pid <= 0 || pid === process.pid) return false;
-    try { process.kill(pid, 'SIGTERM'); } catch (_) {}
-    if (process.platform === 'win32') {
-      try { spawnSync('taskkill', ['/F', '/T', '/PID', String(pid)], { stdio: 'ignore', timeout: 3000 }); } catch (_) {}
-    }
-    return true;
-  }
+  /* killPidQuiet, purgeProfileLockFiles, gracefulCloseBrowser are module-scope (defined above spool()). */
 
   function teardownAll(reason) {
     try {
@@ -1847,7 +1979,7 @@ async function runSpoolWatcher(instance, spoolDir) {
       const sessionsFile = browserSessionsFile(process.cwd());
       const ports = readJsonFile(portsFile, {});
       for (const [sid, entry] of Object.entries(ports)) {
-        if (entry && Number.isFinite(entry.pid)) killPidQuiet(entry.pid);
+        gracefulCloseBrowser(entry, `teardown:${reason}`);
       }
       try { fs.unlinkSync(portsFile); } catch (_) {}
       try { fs.unlinkSync(sessionsFile); } catch (_) {}
@@ -1860,6 +1992,7 @@ async function runSpoolWatcher(instance, spoolDir) {
         pid: process.pid,
         idle_ms: Date.now() - lastActivityMs,
       }));
+      __shutdownReasonWritten = true;
     } catch (_) {}
 
     try { fs.unlinkSync(STATUS_PATH_FOR_TEARDOWN); } catch (_) {}
@@ -1939,6 +2072,32 @@ async function runSpoolWatcher(instance, spoolDir) {
     }
   }, 60_000);
 
+  const BROWSER_IDLE_LIMIT_MS = parseInt(process.env.PLUGKIT_BROWSER_IDLE_LIMIT_MS, 10) || 10 * 60 * 1000;
+  let lastBrowserActivityMs = Date.now();
+  setInterval(() => {
+    try {
+      const browserIdleMs = Date.now() - lastBrowserActivityMs;
+      if (browserIdleMs < BROWSER_IDLE_LIMIT_MS) return;
+      const portsFile = browserPortsFile(process.cwd());
+      const sessionsFile = browserSessionsFile(process.cwd());
+      const ports = readJsonFile(portsFile, {});
+      let closed = 0;
+      for (const [sid, entry] of Object.entries(ports)) {
+        if (entry && Number.isFinite(entry.pid) && isProcessAliveSync(entry.pid)) {
+          try { gracefulCloseBrowser(entry, 'browser-idle'); closed++; } catch (_) {}
+        }
+      }
+      if (closed > 0) {
+        try { fs.unlinkSync(portsFile); } catch (_) {}
+        try { fs.unlinkSync(sessionsFile); } catch (_) {}
+        logEvent('plugkit', 'browser.idle-closed', { count: closed, idle_ms: browserIdleMs });
+      }
+      lastBrowserActivityMs = Date.now();
+    } catch (e) {
+      console.error(`[browser-idle] error: ${e.message}`);
+    }
+  }, 60_000);
+
   setInterval(() => {
     try {
       const idleMs = Date.now() - lastActivityMs;
@@ -1964,20 +2123,48 @@ async function runSpoolWatcher(instance, spoolDir) {
     }
   }, IDLE_CHECK_MS);
 
-  function handleSignalShutdown(sig) {
+  const SHUTDOWN_REQUEST_PATH = path.join(spoolDir, '.shutdown-requested');
+  setInterval(() => {
     try {
-      fs.writeFileSync(SHUTDOWN_REASON_PATH, JSON.stringify({
-        reason: sig.toLowerCase(),
-        ts: Date.now(),
-        pid: process.pid,
-      }));
-    } catch (_) {}
-    try { clearBootActive(); } catch (_) {}
-    try { releaseLock(); } catch (_) {}
-    process.exit(0);
+      if (!fs.existsSync(SHUTDOWN_REQUEST_PATH)) return;
+      let reqReason = 'shutdown-requested';
+      try {
+        const raw = fs.readFileSync(SHUTDOWN_REQUEST_PATH, 'utf-8').trim();
+        if (raw) {
+          try { const j = JSON.parse(raw); if (j && j.reason) reqReason = String(j.reason); }
+          catch (_) { reqReason = raw.slice(0, 64); }
+        }
+      } catch (_) {}
+      try { fs.unlinkSync(SHUTDOWN_REQUEST_PATH); } catch (_) {}
+      handleSignalShutdown(reqReason.toUpperCase());
+    } catch (e) {
+      console.error(`[shutdown-request] error: ${e.message}`);
+    }
+  }, 2000);
+
+  let _signalShutdownInFlight = false;
+  function handleSignalShutdown(sig) {
+    if (_signalShutdownInFlight) return;
+    _signalShutdownInFlight = true;
+    try { teardownAll(sig.toLowerCase()); } catch (_) {
+      try {
+        fs.writeFileSync(SHUTDOWN_REASON_PATH, JSON.stringify({
+          reason: sig.toLowerCase(),
+          ts: Date.now(),
+          pid: process.pid,
+          teardown_failed: true,
+        }));
+        __shutdownReasonWritten = true;
+      } catch (__) {}
+      try { clearBootActive(); } catch (__) {}
+      try { releaseLock(); } catch (__) {}
+      process.exit(0);
+    }
   }
   process.on('SIGINT', () => handleSignalShutdown('SIGINT'));
   process.on('SIGTERM', () => handleSignalShutdown('SIGTERM'));
+  process.on('SIGBREAK', () => handleSignalShutdown('SIGBREAK'));
+  process.on('SIGHUP', () => handleSignalShutdown('SIGHUP'));
   process.on('exit', () => { try { clearBootActive(); } catch (_) {} releaseLock(); });
 
   try {
@@ -2015,8 +2202,9 @@ async function runSpoolWatcher(instance, spoolDir) {
     prior_status: _priorStatus,
     prior_status_age_ms: _priorStatus && Number.isFinite(_priorStatus.ts) ? Date.now() - _priorStatus.ts : null,
   };
-  const _PLANNED_REASONS = new Set(['idle', 'sigterm', 'version-change', 'wrapper-change', 'peer-stale-takeover', 'version-drift', 'external-planned']);
-  const _isPlannedBoot = _priorShutdown && _PLANNED_REASONS.has(_priorShutdown.reason);
+  const _UNPLANNED_REASONS = new Set(['uncaughtexception', 'unhandledrejection', 'wasm-abort', 'wasm-abort-graceful']);
+  const _normalizedShutdownReason = _priorShutdown && _priorShutdown.reason ? String(_priorShutdown.reason).toLowerCase() : null;
+  const _isPlannedBoot = !!_normalizedShutdownReason && !_UNPLANNED_REASONS.has(_normalizedShutdownReason);
   const _isFirstBoot = !_priorShutdown && !_priorStatus;
   const UNPLANNED_RESTART_MARKER = path.join(spoolDir, '.unplanned-restart.json');
   const HEARTBEAT_RECENT_MS = 60_000;
@@ -2057,7 +2245,11 @@ async function runSpoolWatcher(instance, spoolDir) {
         history,
       }, null, 2));
     } catch (_) {}
-    console.error(`[plugkit-wasm] UNPLANNED RESTART detected — prior watcher died without writing .shutdown-reason.json. prior_status_age_ms=${restartContext.prior_status_age_ms} boot_reason=${_bootReason}`);
+    if (_isPlannedBoot) {
+      console.log(`[plugkit-wasm] planned restart: prior reason="${_priorShutdown.reason}" boot_reason=${_bootReason}`);
+    } else {
+      console.error(`[plugkit-wasm] UNPLANNED RESTART detected — prior watcher died without writing .shutdown-reason.json. prior_status_age_ms=${restartContext.prior_status_age_ms} boot_reason=${_bootReason}`);
+    }
   }
   try { fs.unlinkSync(SHUTDOWN_REASON_PATH); } catch (_) {}
   logEvent('plugkit', 'watcher.boot', { version: _bootVersion, in_dir: inDir, out_dir: outDir, spool_dir: spoolDir, ...restartContext });