skalpel 3.0.6 → 3.0.8

package/npm-bin/skalpel.js

@@ -238,21 +238,66 @@ function runUninstall(rest) {
   if (cleanupData) args.push('--cleanup-data');
   if (dryRun) args.push('--dry-run');
 
+  // X4 fix: pass a temp summary file path; postinstall writes a JSON
+  // structure with per-phase counts so we can print a truthful
+  // message instead of unconditionally claiming success.
+  const summaryFile = path.join(
+    os.tmpdir(),
+    `skalpel-uninstall-summary-${process.pid}-${Date.now()}.json`
+  );
+  const childEnv = Object.assign({}, process.env, {
+    SKALPEL_UNINSTALL_SUMMARY_FILE: summaryFile,
+  });
+
   const result = spawnSync(process.execPath, [postinstall, ...args], {
     stdio: 'inherit',
+    env: childEnv,
   });
   if (result.error) {
+    try { fs.rmSync(summaryFile, { force: true }); } catch (_) {}
     emitError(process.stderr, 'Uninstall failed', result.error.message, '→ Try `npm uninstall -g skalpel`.');
     return 1;
   }
   if (result.status !== 0) {
+    try { fs.rmSync(summaryFile, { force: true }); } catch (_) {}
     return result.status === null ? 1 : result.status;
   }
 
+  let summary = null;
+  try {
+    summary = JSON.parse(fs.readFileSync(summaryFile, 'utf8'));
+  } catch (_) {
+    // Older postinstall didn't write one, or file removed mid-flight.
+  } finally {
+    try { fs.rmSync(summaryFile, { force: true }); } catch (_) {}
+  }
+
   const colored = process.stdout.isTTY && !process.env.NO_COLOR;
   const dim = colored ? theme.dim : (s) => s;
   const ok = colored ? theme.mint('✓') : '✓';
-  process.stdout.write(`\n${ok} skalpel state removed from this machine.\n`);
+
+  if (summary) {
+    const rc = summary.rcBlocksRemoved | 0;
+    const svc = summary.serviceFileRemoved ? 1 : 0;
+    const data = summary.userDataFilesRemoved | 0;
+    const total = rc + svc + data;
+    if (total === 0 && !summary.dryRun) {
+      process.stdout.write(`\n${ok} skalpel state was already clean — nothing to remove.\n`);
+    } else {
+      const parts = [
+        `${rc} shell-rc block${rc === 1 ? '' : 's'}`,
+        `${svc} service entr${svc === 1 ? 'y' : 'ies'}`,
+      ];
+      if (summary.cleanupDataRequested) {
+        parts.push(`${data} user-data file${data === 1 ? '' : 's'}`);
+      }
+      const prefix = summary.dryRun ? '[dry-run] would remove' : 'Removed';
+      process.stdout.write(`\n${ok} ${prefix}: ${parts.join(', ')}.\n`);
+    }
+  } else {
+    // Fallback to the old unconditional message if no summary made it back.
+    process.stdout.write(`\n${ok} skalpel state removed from this machine.\n`);
+  }
   process.stdout.write(`${dim('To finish removal, also run:')}\n`);
   process.stdout.write(`  npm uninstall -g skalpel\n`);
   return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skalpel",
-  "version": "3.0.6",
+  "version": "3.0.8",
   "description": "Skalpel — local proxy and TUI for coding agents (skalpel + skalpeld bundle).",
   "license": "Apache-2.0",
   "homepage": "https://skalpel.ai",
@@ -54,10 +54,10 @@
     "x64"
   ],
   "optionalDependencies": {
-    "@skalpelai/skalpel-darwin-arm64": "3.0.6",
-    "@skalpelai/skalpel-darwin-x64": "3.0.6",
-    "@skalpelai/skalpel-linux-arm64": "3.0.6",
-    "@skalpelai/skalpel-linux-x64": "3.0.6",
-    "@skalpelai/skalpel-win32-x64": "3.0.6"
+    "@skalpelai/skalpel-darwin-arm64": "3.0.8",
+    "@skalpelai/skalpel-darwin-x64": "3.0.8",
+    "@skalpelai/skalpel-linux-arm64": "3.0.8",
+    "@skalpelai/skalpel-linux-x64": "3.0.8",
+    "@skalpelai/skalpel-win32-x64": "3.0.8"
   }
 }

package/postinstall/index.js

@@ -110,60 +110,113 @@ function helpText() {
 }
 
 // B29: best-effort delete of user data on --uninstall --cleanup-data.
-// Skipped silently when files / dirs are absent.
+// X5 fix: previously silent on absent files. Now logs "absent — skip"
+// for every checked path so the user can see what was inspected.
+// X7 fix: also clean cache/, skalpel-tui.log, skalpeld.log, socket
+// markers, and stats.cache — the pre-X7 list was just 4 paths and
+// left those behind, defeating the "full wipe" promise.
 function cleanupUserData({ dryRun }) {
   const removed = [];
-  const targets = [
-    paths.authFile(),
-    paths.configToml(),
-    paths.lockFile(),
+  const skipped = [];
+  const cfg = paths.configDir();
+  const fileTargets = [
+    paths.authFile(),                             // auth.json
+    paths.configToml(),                           // config.toml
+    paths.lockFile(),                             // skalpeld.lock
+    path.join(cfg, 'skalpel-tui.log'),            // X7: TUI logger sink
+    path.join(cfg, 'skalpeld.log'),               // X7: daemon log
+    path.join(cfg, 'skalpeld.sock'),              // X7: daemon socket
+    path.join(cfg, 'skalpeld.sock.path'),         // X7: socket path marker
+    path.join(cfg, 'stats.cache'),                // X7: stats cache
+  ];
+  const dirTargets = [
+    paths.logsDir(),                              // logs/
+    path.join(cfg, 'cache'),                      // X7: model-fingerprint cache
   ];
-  for (const t of targets) {
+
+  for (const t of fileTargets) {
+    const present = fs.existsSync(t);
     if (dryRun) {
-      log.dryRun(`uninstall-cleanup: would rm ${t}`);
-      removed.push(t);
+      if (present) {
+        log.dryRun(`uninstall-cleanup: would rm ${t}`);
+        removed.push(t);
+      } else {
+        log.dryRun(`uninstall-cleanup: ${t} absent — would skip`);
+        skipped.push(t);
+      }
       continue;
     }
     try {
-      if (fs.existsSync(t)) {
+      if (present) {
         fs.rmSync(t, { force: true });
         log.info(`uninstall-cleanup: removed ${t}`);
         removed.push(t);
+      } else {
+        log.info(`uninstall-cleanup: ${t} absent — skip`);
+        skipped.push(t);
       }
     } catch (err) {
       log.warn(`uninstall-cleanup: rm ${t} failed: ${err.message}`);
     }
   }
-  const lDir = paths.logsDir();
-  if (dryRun) {
-    log.dryRun(`uninstall-cleanup: would rm -r ${lDir}`);
-    removed.push(lDir);
-  } else {
+  for (const d of dirTargets) {
+    const present = fs.existsSync(d);
+    if (dryRun) {
+      if (present) {
+        log.dryRun(`uninstall-cleanup: would rm -r ${d}`);
+        removed.push(d);
+      } else {
+        log.dryRun(`uninstall-cleanup: ${d} absent — would skip`);
+        skipped.push(d);
+      }
+      continue;
+    }
     try {
-      if (fs.existsSync(lDir)) {
-        fs.rmSync(lDir, { recursive: true, force: true });
-        log.info(`uninstall-cleanup: removed ${lDir}`);
-        removed.push(lDir);
+      if (present) {
+        fs.rmSync(d, { recursive: true, force: true });
+        log.info(`uninstall-cleanup: removed ${d}`);
+        removed.push(d);
+      } else {
+        log.info(`uninstall-cleanup: ${d} absent — skip`);
+        skipped.push(d);
       }
     } catch (err) {
-      log.warn(`uninstall-cleanup: rm -r ${lDir} failed: ${err.message}`);
+      log.warn(`uninstall-cleanup: rm -r ${d} failed: ${err.message}`);
     }
   }
-  // Try to remove the (now-empty) configDir; ignore ENOTEMPTY which
-  // means the user has other state under it we don't own.
-  const cfg = paths.configDir();
+  // Try to remove the (now-empty) configDir; ENOTEMPTY means the
+  // user has third-party state under it we deliberately did not
+  // touch — leave it alone.
   if (!dryRun) {
     try {
       fs.rmdirSync(cfg);
       log.info(`uninstall-cleanup: removed empty ${cfg}`);
       removed.push(cfg);
-    } catch (_) {
-      // non-empty or missing — leave alone.
+    } catch (err) {
+      if (err.code === 'ENOTEMPTY') {
+        log.info(`uninstall-cleanup: ${cfg} not empty (third-party files preserved) — skip rmdir`);
+      } else if (err.code !== 'ENOENT') {
+        log.warn(`uninstall-cleanup: rmdir ${cfg} failed: ${err.message}`);
+      }
     }
   } else {
     log.dryRun(`uninstall-cleanup: would rmdir (if empty) ${cfg}`);
   }
-  return { removed };
+  return { removed, skipped };
+}
+
+// X4 fix: write a JSON summary of what the uninstall actually did to
+// the path in SKALPEL_UNINSTALL_SUMMARY_FILE, so npm-bin/skalpel.js
+// (which inherited stdio to this child) can derive a truthful count
+// summary without parsing log lines.
+function writeSummaryFile(summary) {
+  const out = process.env.SKALPEL_UNINSTALL_SUMMARY_FILE;
+  if (!out) return;
+  try {
+    fs.writeFileSync(out, JSON.stringify(summary), { mode: 0o600 });
+  } catch (err) {
+    log.warn(`uninstall: failed to write summary to ${out}: ${err.message}`);
+  }
 }
 
 function main(argv) {
@@ -192,21 +245,44 @@ function main(argv) {
   const allWarnings = [];
 
   if (opts.uninstall) {
+    // X4 fix: count what was actually removed in each phase so the
+    // shim can print a truthful summary instead of a blanket "✓ state
+    // removed" that lies when the system was already clean.
+    const summary = {
+      rcBlocksRemoved: 0,
+      serviceFileRemoved: false,
+      serviceUnloadSucceeded: 0,
+      serviceUnloadFailedAllowed: 0,
+      serviceUnloadSkipped: false,
+      userDataFilesRemoved: 0,
+      userDataFilesSkipped: 0,
+      cleanupDataRequested: !!opts.cleanupData,
+      dryRun: !!opts.dryRun,
+      errors: [],
+    };
     try {
       const stepCount = opts.cleanupData ? 3 : 2;
       log.step(1, stepCount, 'env-uninject', 'remove managed-block from rc files');
-      envInject.uninject({ dryRun: opts.dryRun });
+      const ei = envInject.uninject({ dryRun: opts.dryRun }) || {};
+      summary.rcBlocksRemoved = Array.isArray(ei.removed) ? ei.removed.length : 0;
 
       log.step(2, stepCount, 'service-unregister', `OS=${process.platform}`);
       const ur = serviceRegister.unregister({ dryRun: opts.dryRun }) || {};
       if (Array.isArray(ur.errors) && ur.errors.length) {
         allWarnings.push(...ur.errors);
+        summary.errors.push(...ur.errors);
       }
+      summary.serviceFileRemoved = !!ur.serviceFileRemoved;
+      summary.serviceUnloadSucceeded = ur.succeeded || 0;
+      summary.serviceUnloadFailedAllowed = ur.failedAllowed || 0;
+      summary.serviceUnloadSkipped = !!ur.skipped;
 
       // B29: optional user-data cleanup.
       if (opts.cleanupData) {
-        log.step(3, stepCount, 'cleanup-user-data', 'delete auth.json/config.toml/lock/logs');
-        cleanupUserData({ dryRun: opts.dryRun });
+        log.step(3, stepCount, 'cleanup-user-data', 'delete auth.json/config.toml/lock/logs/cache');
+        const cd = cleanupUserData({ dryRun: opts.dryRun }) || {};
+        summary.userDataFilesRemoved = Array.isArray(cd.removed) ? cd.removed.length : 0;
+        summary.userDataFilesSkipped = Array.isArray(cd.skipped) ? cd.skipped.length : 0;
       } else {
         log.info(
           'uninstall: user data preserved (auth.json/config.toml/lock/logs). ' +
@@ -218,8 +294,11 @@ function main(argv) {
       if (opts.verbose) {
         process.stderr.write(`${err.stack}\n`);
       }
+      summary.errors.push(err.message);
+      writeSummaryFile(summary);
       return 0;
     }
+    writeSummaryFile(summary);
     if (allWarnings.length) {
       log.warn(`postinstall wizard finished (${mode} uninstall) with ${allWarnings.length} warning(s)`);
     } else {

package/postinstall/lib/env-inject.js

@@ -113,6 +113,13 @@ function uninject({ dryRun }) {
     if (r.changed) {
       log.info(`uninstall: removed managed block from ${rc.path} (${rc.shell})`);
       removed.push(rc.path);
+    } else {
+      // X6 fix: previously silent. Surface "checked, nothing to remove"
+      // so the user can tell the rc file was inspected — Owen's #discord
+      // 2026-05-12 Windows report only logged "powershell-legacy absent"
+      // and never mentioned the modern powershell rc which existed but
+      // had no managed block.
+      log.info(`uninstall: no managed block in ${rc.path} (${rc.shell}) — skip`);
     }
   }
   return { removed };

package/postinstall/lib/service-register.js

@@ -161,58 +161,119 @@ function verifyBinary() {
   return { bin, stat };
 }
 
-// B50: two-phase unregister with rollback markers. Phase 1 collects
-// what would be undone; phase 2 executes each step and on failure
-// runs the prior-step undo so the system does not end up in a
-// half-detached state.
+// fallbackUnloadCommands returns commands that do not depend on
+// installed-state files. Used when the per-OS primary unload path
+// requires a precondition (rendered PS1, etc.) that may be missing —
+// e.g. an aborted install or a prior uninstall already deleted it.
+function fallbackUnloadCommands() {
+  switch (process.platform) {
+    case 'win32':
+      // schtasks.exe lives in System32 and is always present; the
+      // PS1 helper only existed to template params, so we invoke
+      // schtasks directly when the helper is gone.
+      return [
+        ['schtasks.exe', ['/End', '/TN', 'Skalpel\\skalpel-daemon'], { allowFail: true }],
+        ['schtasks.exe', ['/Delete', '/TN', 'Skalpel\\skalpel-daemon', '/F'], { allowFail: true }],
+      ];
+    default:
+      return [];
+  }
+}
+
+// Preflight + three-state outcome tracking. We distinguish:
+//   - succeeded:           command exited 0
+//   - skipped-precondition: a file the command needs is absent
+//   - failed-allowed:      command exited non-0, allowFail=true
+//   - failed-hard:         command exited non-0, allowFail=false
+// The pre-X1 code lumped succeeded + failed-allowed into "ok",
+// producing "1/1 ok" reports when an unregister silently failed
+// because the service was never registered to begin with. Owen
+// (#discord, 2026-05-12) saw this on Windows when the rendered PS1
+// helper was gone and PowerShell errored loudly while the wizard
+// still reported success.
 function unregister({ dryRun }) {
   const dest = paths.servicePath();
+  const ps1 = renderedPowerShellPath();
+  const servicePresent = fs.existsSync(dest);
+  const ps1Present = fs.existsSync(ps1);
+
   if (dryRun) {
     log.dryRun(`uninstall: would unregister service at ${dest}`);
-    for (const [bin, args] of unloadCommands()) {
-      log.dryRun(`  would run: ${bin} ${args.join(' ')}`);
+    if (!servicePresent) {
+      log.dryRun(`  service file absent at ${dest} — would skip unload commands`);
+    } else {
+      const cmds = (process.platform === 'win32' && !ps1Present)
+        ? fallbackUnloadCommands()
+        : unloadCommands();
+      for (const [bin, args] of cmds) {
+        log.dryRun(`  would run: ${bin} ${args.join(' ')}`);
+      }
     }
     log.dryRun(`  would rm ${dest}`);
-    return { dryRun: true };
+    if (process.platform === 'win32') {
+      log.dryRun(`  would rm ${ps1}`);
+    }
+    return { dryRun: true, succeeded: 0, skipped: 0, failedAllowed: 0, serviceFileRemoved: false };
+  }
+
+  let cmds;
+  if (!servicePresent) {
+    log.info(`uninstall: service file absent at ${dest} — nothing registered to unload`);
+    cmds = [];
+  } else if (process.platform === 'win32' && !ps1Present) {
+    log.warn(`uninstall: PowerShell helper absent at ${ps1} — using direct schtasks fallback`);
+    cmds = fallbackUnloadCommands();
+  } else {
+    cmds = unloadCommands();
   }
 
-  // Phase 1: plan the steps.
-  const steps = unloadCommands().map(([bin, args, opts]) => ({
-    bin,
-    args,
-    allowFail: !!(opts && opts.allowFail),
-    done: false,
-  }));
+  let succeeded = 0;
+  let failedAllowed = 0;
   const errors = [];
 
-  // Phase 2: execute. On hard failure, log every prior step (we do not
-  // attempt to re-bootstrap because that would re-install the daemon).
-  for (const step of steps) {
-    const r = spawnSync(step.bin, step.args, { stdio: 'inherit' });
-    if (r.status !== 0 && !step.allowFail) {
-      const msg = `uninstall: ${step.bin} ${step.args.join(' ')} exited ${r.status}`;
+  for (const [bin, args, opts] of cmds) {
+    const allowFail = !!(opts && opts.allowFail);
+    const r = spawnSync(bin, args, { stdio: 'inherit' });
+    if (r.status === 0) {
+      succeeded += 1;
+    } else if (allowFail) {
+      failedAllowed += 1;
+      log.info(`uninstall: ${bin} ${args.join(' ')} exited ${r.status} (allowed)`);
+    } else {
+      const msg = `uninstall: ${bin} ${args.join(' ')} exited ${r.status}`;
       errors.push(msg);
       log.warn(`${msg}; rolling forward to file removal`);
-    } else {
-      step.done = true;
     }
   }
-  log.info(
-    `uninstall: phase 2 complete: ${steps.filter((s) => s.done).length}/${steps.length} ok` +
-    (errors.length ? ` (${errors.length} errors)` : '')
-  );
 
-  if (fs.existsSync(dest)) {
+  if (cmds.length === 0) {
+    log.info('uninstall: phase 2 skipped — service was not registered');
+  } else {
+    log.info(
+      `uninstall: phase 2 complete: ${succeeded} succeeded, ` +
+      `${failedAllowed} failed (allowed)` +
+      (errors.length ? `, ${errors.length} hard errors` : '')
+    );
+  }
+
+  let serviceFileRemoved = false;
+  if (servicePresent) {
     fs.unlinkSync(dest);
     log.info(`uninstall: removed ${dest}`);
+    serviceFileRemoved = true;
   }
-  // Also remove the rendered helper PS1 on Windows.
-  const ps1 = renderedPowerShellPath();
-  if (process.platform === 'win32' && fs.existsSync(ps1)) {
+  if (process.platform === 'win32' && ps1Present) {
     fs.unlinkSync(ps1);
     log.info(`uninstall: removed ${ps1}`);
   }
-  return { removed: true, errors };
+  return {
+    removed: serviceFileRemoved,
+    serviceFileRemoved,
+    succeeded,
+    skipped: cmds.length === 0 ? 1 : 0,
+    failedAllowed,
+    errors,
+  };
 }
 
 function run({ dryRun }) {
@@ -290,4 +351,4 @@ function run({ dryRun }) {
   return { skipped: false, registered: true, warnings };
 }
 
-module.exports = { run, unregister, templatePath, loadCommands, unloadCommands, launchdTarget };
+module.exports = { run, unregister, templatePath, loadCommands, unloadCommands, fallbackUnloadCommands, launchdTarget };