kenaz 0.3.11 → 0.3.12

package/lib/cli.js

@@ -14,7 +14,7 @@ const dash = require('./dashboard');
 const PKG_ROOT = path.resolve(__dirname, '..');
 const PKG = require('../package.json');
 const MIN_NODE = 18;
-const USAGE = 'usage: kenaz <install|uninstall|status|doctor|init|ygg join <key>|ygg status|ygg leave|alaya status|alaya register|model [set <id>|unset] [--rigor r]|stats [--days N] [--json]|learn <add|list|rm>> [--dry-run] [--home <dir>] [--no-service] [--no-claude] [--no-codex] [--keep-dashboard] [--server-bin <path>]';
+const USAGE = 'usage: kenaz <install|uninstall|status|doctor|init|ygg join <key>|ygg create [--name N]|ygg status|ygg leave|alaya status|alaya register|model [set <id>|unset] [--rigor r]|stats [--days N] [--json]|learn <add|list|rm>> [--dry-run] [--home <dir>] [--no-service] [--no-claude] [--no-codex] [--keep-dashboard] [--server-bin <path>]';
 
 function parseArgs(argv) {
   const o = { cmd: argv[0], flags: {} };
@@ -114,7 +114,7 @@ function retryBusy(fn, tries = 10) {
   }
 }
 
-function install(p, flags, out, deps = {}) {
+async function install(p, flags, out, deps = {}) {
   const dry = !!flags['dry-run'];
   const tag = dry ? '[dry-run] ' : '';
   const log = (m) => out(tag + m);
@@ -167,7 +167,10 @@ function install(p, flags, out, deps = {}) {
     if (flags['no-service']) a.push('--no-service');
     if (dry) a.push('--dry-run');
     const ver = hasClaude ? inst.claudeVersion() : null;
-    if (inst.main(a, out, () => ver) !== 0) rc = 1;
+    let plan = null;
+    if (inst.main(a, out, () => ver, { sh: deps.sh, platform: deps.platform, uid: deps.uid, onPlan: (x) => { plan = x; } }) !== 0) rc = 1;
+    // TASK_2418: the service was (re)started above; confirm the running server is the one just installed.
+    if (!dry && plan && srv && !flags['no-service']) await inst.verifyRuntime(plan, srv.version, out, deps.verify);
   }
   if (dry && hasClaude) out(`[dry-run] note: plugin paths above are the packaged core; after install they live under ${path.join(p.core, 'plugins')}`);
 
@@ -235,6 +238,10 @@ async function doctor(p, flags, out, deps = {}) {
   let ver = ''; try { ver = JSON.parse(r.body).version; } catch (_) { /* health body is optional */ }
   add('server reachable', r.ok ? 'ok' : 'FAIL', r.detail + (ver ? `, version ${ver}` : ''));
 
+  try { // TASK_2413: which mechanism restarts the server after a reboot (read-only; `deps.sh` / `deps.platform` for tests)
+    const sm = installer().detectServiceMode(p.home, p.core, deps.sh, deps.platform);
+    add('service mode', sm.mode === 'manual' ? 'skip' : 'ok', sm.mode + ' (' + sm.detail + ')');
+  } catch (e) { add('service mode', 'skip', 'unknown: ' + e.message); }
   const d = dash.detect(p.home, deps.dashboard);
   if (!d.installed) add('dashboard', 'skip', 'no Kenaz Dashboard on this machine');
   else {
@@ -284,13 +291,13 @@ async function doctor(p, flags, out, deps = {}) {
   if (rea) {
     const r = rea.detectRea({ home: p.home, projectPath: process.cwd() });
     add('rea (optional)', r.installed ? 'ok' : 'skip', r.installed ? 'MCP registered in ' + [r.claude && 'claude', r.codex && 'codex'].filter(Boolean).join(', ')
-      : `not installed; \`${rea.SETUP_CMD}\` lets Ansuz analyse reference products` + (r.nodeOk ? '' : ` (needs Node >=22.19, found ${process.versions.node})`));
+      : `not installed; \`${r.setupCmd || rea.SETUP_CMD}\` lets Ansuz analyse reference products` + (r.nodeOk ? '' : ` (needs Node >=22.19, found ${process.versions.node})`));
   }
   for (const [l, s, d] of rows) out(`${s.padEnd(4)}  ${l.padEnd(20)} ${d}`);
   return rows.some((r) => r[1] === 'FAIL') ? 1 : 0;
 }
 
-// `kenaz ygg join|status|leave ...` and `kenaz init`: short forms of the same core scripts the
+// `kenaz ygg join|create|status|leave ...` and `kenaz init`: short forms of the same core scripts the
 // /kenaz (Claude) and $kenaz (Codex) commands run, from a normal terminal in the project folder.
 function passthrough(argv, deps) {
   const p = paths(os.homedir());
@@ -353,8 +360,11 @@ function run(argv, out = console.log, deps = {}) {
   const fn = { install, uninstall, status, doctor }[cmd];
   if (!fn) { out(USAGE); return 2; }
   if (!nodeOk()) { out(`Node.js >= ${MIN_NODE} is required (found ${process.versions.node}). Install it from https://nodejs.org and rerun.`); return 1; }
-  try { return fn(paths(path.resolve(flags.home || os.homedir())), flags, out, deps); }
-  catch (e) { out('kenaz ' + cmd + ': ERROR ' + e.message); return 1; }
+  const fail = (e) => { out('kenaz ' + cmd + ': ERROR ' + e.message); return 1; };
+  try {
+    const r = fn(paths(path.resolve(flags.home || os.homedir())), flags, out, deps);
+    return r && typeof r.then === 'function' ? r.catch(fail) : r;
+  } catch (e) { return fail(e); }
 }
 
 module.exports = { run, parseArgs, platformServer, paths, stopOwnServer, retryBusy };

package/lib/cli.test.js

@@ -107,3 +107,13 @@ test('retryBusy retries a locked copy and then succeeds; other errors are thrown
   assert.strictEqual(n, 3);
   assert.throws(() => retryBusy(() => { const e = new Error('nope'); e.code = 'ENOENT'; throw e; }, 5), /nope/);
 });
+
+// TASK_2413: doctor names the active service mode. Stubbed `sh` + forced platform: no real system command runs.
+test('doctor reports the service mode (cron on a Linux box without systemd, manual when nothing is installed)', async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-doc-'));
+  const dashboard = { candidateDirs: () => [], procs: () => [], portPids: () => [] };
+  const go = async (sh) => { const l = []; await run(['doctor', '--home', home, '--no-claude', '--no-codex'], (x) => l.push(x), { dashboard, sh, platform: 'linux' }); return l.find((x) => /service mode/.test(x)); };
+  const cron = await go((c) => (c === 'crontab' ? { status: 0, stdout: '@reboot x # kenaz-server (managed by kenaz install)\n' } : { status: 1, stdout: '' }));
+  assert.match(cron, /^ok\s+service mode\s+cron/);
+  assert.match(await go(() => ({ status: 1, stdout: '' })), /^skip\s+service mode\s+manual/);
+});

package/lib/dashboard.test.js

@@ -12,9 +12,9 @@ const tmpHome = () => fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-dash-'));
 const fake = (o = {}) => ({ candidateDirs: () => o.dirs || [], procs: () => o.procs || [], portPids: () => o.owners || [] });
 const DASH_PROC = { pid: 4242, name: 'kenaz-dashboard.exe', exe: 'C:/Users/u/AppData/Local/BLOCK ACTION/kenaz-dashboard.exe' };
 
-test('install with a running Dashboard owning the port: Chinese steps, rc 1, nothing written', () => {
+test('install with a running Dashboard owning the port: Chinese steps, rc 1, nothing written', async () => {
   const home = tmpHome(), lines = [];
-  const rc = run(['install', '--home', home, '--no-claude', '--no-codex'], (m) => lines.push(m), { dashboard: fake({ procs: [DASH_PROC], owners: [4242] }) });
+  const rc = await run(['install', '--home', home, '--no-claude', '--no-codex'], (m) => lines.push(m), { dashboard: fake({ procs: [DASH_PROC], owners: [4242] }) });
   assert.strictEqual(rc, 1);
   assert.ok(lines.join('\n').includes('npx kenaz install') && lines.join('\n').includes('開機時啟動'));
   assert.ok(!fs.existsSync(path.join(home, '.kenaz')), 'no files, no service');
@@ -43,7 +43,7 @@ test('a foreign process on the port is not treated as the Dashboard', () => {
 
 test('doctor flags a running Dashboard, its port and Dashboard plugin dirs', async () => {
   const home = tmpHome(), lines = [];
-  const rc = await run(['doctor', '--home', home, '--no-claude', '--no-codex'], (m) => lines.push(m), { dashboard: fake({ dirs: [os.tmpdir()], procs: [DASH_PROC], owners: [4242] }) });
+  const rc = await run(['doctor', '--home', home, '--no-claude', '--no-codex'], (m) => lines.push(m), { dashboard: fake({ dirs: [os.tmpdir()], procs: [DASH_PROC], owners: [4242] }), sh: () => ({ status: 1, stdout: '' }) });
   assert.strictEqual(rc, 1);
   assert.ok(lines.some((l) => /^FAIL\s+dashboard running/.test(l)) && lines.some((l) => /^FAIL\s+port \d+ owner/.test(l)));
   const d = dash.detect(home, fake({ dirs: [os.tmpdir()] }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kenaz",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "description": "Install Kenaz (plugin, hooks, kenaz-server) for Claude Code and Codex: npx kenaz install",
   "bin": {
     "kenaz": "bin/kenaz.js"
@@ -20,11 +20,11 @@
     "test": "node --test lib/cli.test.js"
   },
   "optionalDependencies": {
-    "@kenazai/server-darwin-arm64": "0.3.11",
-    "@kenazai/server-darwin-x64": "0.3.11",
-    "@kenazai/server-linux-arm64": "0.3.11",
-    "@kenazai/server-linux-x64": "0.3.11",
-    "@kenazai/server-win32-x64": "0.3.11"
+    "@kenazai/server-darwin-arm64": "0.3.12",
+    "@kenazai/server-darwin-x64": "0.3.12",
+    "@kenazai/server-linux-arm64": "0.3.12",
+    "@kenazai/server-linux-x64": "0.3.12",
+    "@kenazai/server-win32-x64": "0.3.12"
   },
   "license": "UNLICENSED",
   "repository": {

package/vendor/install-kenaz-cli.js

@@ -13,6 +13,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const http = require('http');
 const { spawnSync } = require('child_process');
 
 const ENV_KEY = 'CLAUDE_CODE_PLUGIN_DIRS';
@@ -144,7 +145,30 @@ function systemdUnit(bin, core, nodeExe) {
   return '[Unit]\nDescription=Kenaz server (headless backend)\nAfter=network.target\n\n[Service]\nExecStart=' + bin + '\nEnvironment=KENAZ_SOURCE_DIR=' + core + '\nEnvironment=PATH=' + servicePath(nodeExe) + '\nRestart=on-failure\n\n[Install]\nWantedBy=default.target\n';
 }
 
-function servicePlan(home, bin, core, platform = process.platform) {
+// TASK_2413: no usable systemd user session (containers, WSL1, minimal servers) -> `systemctl --user enable --now`
+// silently does nothing. Fall back to an @reboot crontab entry ('cron') or, without crontab, a manual start ('manual').
+const CRON_MARK = '# kenaz-server (managed by kenaz install)';
+const shq = (v) => "'" + String(v).replace(/'/g, "'\\''") + "'";
+function cronStartCmd(bin, core, log, nodeExe) {
+  return 'KENAZ_SOURCE_DIR=' + shq(core) + ' PATH=' + shq(servicePath(nodeExe)) + ' ' + shq(bin) + ' >> ' + shq(log) + ' 2>&1';
+}
+function cronLine(bin, core, log, nodeExe) { // % is special in crontab
+  return '@reboot ' + cronStartCmd(bin, core, log, nodeExe).replace(/%/g, '\\%') + ' ' + CRON_MARK;
+}
+// stop exactly this binary (never by process name: another install's kenaz-server must survive). An upgraded
+// process still runs the unlinked inode, which /proc reports as "<path> (deleted)".
+function stopCmd(plan) {
+  const b = shq(plan.bin);
+  return 'for p in $(pgrep -x kenaz-server); do e=$(readlink /proc/$p/exe); ' +
+    '[ "$e" = ' + b + ' ] || [ "$e" = ' + shq(plan.bin + ' (deleted)') + ' ] && kill $p; done; true';
+}
+// start now, detached from the installer (new session when setsid exists), output to the log
+function detachedStartCmd(plan) {
+  return 'if command -v setsid >/dev/null 2>&1; then S=setsid; else S=; fi; ' +
+    'KENAZ_SOURCE_DIR=' + shq(plan.core) + ' PATH=' + shq(servicePath()) + ' $S nohup ' + shq(plan.bin) + ' >> ' + shq(plan.log) + ' 2>&1 < /dev/null &';
+}
+
+function servicePlan(home, bin, core, platform = process.platform, caps = { systemd: true }) {
   const L = launcherPaths(home);
   if (platform === 'win32') {
     const roaming = home === os.homedir() && process.env.APPDATA ? process.env.APPDATA : path.join(home, 'AppData', 'Roaming');
@@ -155,12 +179,101 @@ function servicePlan(home, bin, core, platform = process.platform) {
     const p = path.join(home, 'Library', 'LaunchAgents', LABEL + '.plist');
     return { kind: 'launchd', files: [[p, launchdPlist(bin, core, L.log)]], unit: p };
   }
+  if (caps.systemd === false) {
+    return { kind: caps.crontab ? 'cron' : 'manual', files: [], bin, core, log: L.log, cronLine: cronLine(bin, core, L.log) };
+  }
   const p = path.join(home, '.config', 'systemd', 'user', 'kenaz-server.service');
   return { kind: 'systemd', files: [[p, systemdUnit(bin, core)]], unit: p };
 }
-const sh = (cmd, args) => spawnSync(cmd, args, { encoding: 'utf8' });
+const sh = (cmd, args, opts) => spawnSync(cmd, args, { encoding: 'utf8', ...(opts || {}) });
+
+// crontab -l: null = no crontab binary; '' = binary present, no crontab yet. All through the injected `run`.
+function readCron(run) {
+  const r = run('crontab', ['-l']);
+  if (!r || r.error || r.status === 127) return null;
+  return r.status === 0 ? String(r.stdout || '') : '';
+}
+function probeLinux(run) {
+  const r = run('systemctl', ['--user', 'show-environment']);
+  const systemd = !!r && !r.error && r.status === 0;
+  return { systemd, crontab: systemd ? undefined : readCron(run) !== null };
+}
+function writeCron(run, current, line) { // line null = remove our entry; keeps every other line; idempotent
+  const keep = current.split('\n').filter((l) => l.trim() && !l.includes(CRON_MARK));
+  const next = line ? keep.concat(line) : keep;
+  const text = next.length ? next.join('\n') + '\n' : '';
+  if (text === current) return false;
+  if (text) run('crontab', ['-'], { input: text }); else run('crontab', ['-r']);
+  return true;
+}
 
-function serviceInstall(plan, dry, log) {
+// TASK_2418: loading/enabling a unit that is already loaded/active is a no-op, so an upgrade must restart it
+// explicitly, after the new binary is in place. launchd KeepAlive respawns the OLD file in the window between
+// stopOwnServer() and the copy (the process then keeps the unlinked inode); systemd `enable --now` does not
+// restart an active unit. restartHint is also the command printed when the version check fails.
+const defaultUid = () => (typeof process.getuid === 'function' ? process.getuid() : 501);
+function restartHint(plan, uid = defaultUid()) {
+  if (plan.kind === 'launchd') return 'launchctl kickstart -k gui/' + uid + '/' + LABEL;
+  if (plan.kind === 'systemd') return 'systemctl --user restart kenaz-server';
+  if (plan.kind === 'cron' || plan.kind === 'manual') return stopCmd(plan) + '; ' + detachedStartCmd(plan);
+  // the launcher works for both the scheduled task and the Startup-folder fallback (no admin rights needed)
+  return 'end kenaz-server.exe in Task Manager, then run: wscript.exe ' + q(plan.files && plan.files[0] ? plan.files[0][0] : 'kenaz-server.vbs');
+}
+function serviceRestart(plan, dry, log, run = sh, uid = defaultUid()) {
+  if (plan.kind === 'cron' || plan.kind === 'manual') { // no supervisor: start it (stopOwnServer freed the old one)
+    log('start now (detached, log ' + plan.log + ')');
+    if (!dry) { fs.mkdirSync(path.dirname(plan.log), { recursive: true }); run('sh', ['-c', detachedStartCmd(plan)]); }
+    return;
+  }
+  if (plan.kind === 'windows') return; // /Create + /Run above start the just-copied exe (stopOwnServer freed it)
+  log(restartHint(plan, uid));
+  if (dry) return;
+  if (plan.kind === 'launchd') {
+    const r = run('launchctl', ['kickstart', '-k', 'gui/' + uid + '/' + LABEL]);
+    if (r && r.status !== 0) { // old macOS / no GUI session domain: unload + load restarts it the long way
+      log('kickstart failed (exit ' + r.status + '), falling back to launchctl unload + load');
+      run('launchctl', ['unload', plan.unit]); run('launchctl', ['load', '-w', plan.unit]);
+    }
+  } else run('systemctl', ['--user', 'restart', 'kenaz-server']);
+}
+
+/** One GET /api/health; resolves { ok, version }. */
+function healthOnce(port, getFn = http.get) {
+  return new Promise((resolve) => {
+    const req = getFn({ host: '127.0.0.1', port, path: '/api/health', timeout: 2000 }, (res) => {
+      let b = ''; res.on('data', (d) => { b += d; });
+      res.on('end', () => { let v = null; try { v = JSON.parse(b).version || null; } catch (_) { /* body optional */ } resolve({ ok: res.statusCode < 500, version: v }); });
+    });
+    req.on('timeout', () => { req.destroy(); resolve({ ok: false, version: null }); });
+    req.on('error', () => resolve({ ok: false, version: null }));
+  });
+}
+/**
+ * TASK_2418: after the service (re)start, ask the running server for its version and compare with the one just
+ * installed. Retries (the server needs a moment to bind). Returns 'ok' | 'mismatch' | 'unreachable'; the last two
+ * print a warning with the exact restart command and do not fail the install.
+ */
+async function verifyRuntime(plan, expected, log, opts = {}) {
+  const port = opts.port || process.env.KENAZ_HTTP_PORT || '18080';
+  const tries = opts.tries || 6, delay = opts.delayMs === undefined ? 1000 : opts.delayMs;
+  const probe = opts.health || ((p) => healthOnce(p));
+  let last = { ok: false, version: null };
+  for (let i = 0; i < tries; i++) {
+    last = await probe(port);
+    if (last.ok && last.version === expected) { log('server: running version ' + expected + ' on :' + port); return 'ok'; }
+    if (i < tries - 1 && delay) await new Promise((r) => setTimeout(r, delay));
+  }
+  const hint = restartHint(plan, opts.uid);
+  if (last.ok && last.version) {
+    log('WARNING: the server on :' + port + ' still reports version ' + last.version + ' but ' + expected + ' was just installed. Restart it: ' + hint);
+    return 'mismatch';
+  }
+  log('WARNING: could not confirm the new server (' + expected + ') on 127.0.0.1:' + port + (last.ok ? ' (no version in /api/health)' : ' (no answer)') + '. If it is not running: ' + hint);
+  return 'unreachable';
+}
+
+function serviceInstall(plan, dry, log, run = sh, uid) {
+  const sh = run; // injectable for tests; shadows the module-level spawnSync wrapper inside this function
   for (const [f, body] of plan.files) { log('write ' + f); if (!dry) { fs.mkdirSync(path.dirname(f), { recursive: true }); fs.writeFileSync(f, body); } }
   if (plan.kind === 'windows') {
     const tr = 'wscript.exe ' + q(plan.files[0][0]);
@@ -178,29 +291,63 @@ function serviceInstall(plan, dry, log) {
     }
   } else if (plan.kind === 'launchd') {
     log('launchctl load -w ' + plan.unit); if (!dry) sh('launchctl', ['load', '-w', plan.unit]);
+    serviceRestart(plan, dry, log, sh, uid);
+  } else if (plan.kind === 'cron' || plan.kind === 'manual') {
+    if (plan.kind === 'cron') {
+      log('crontab: @reboot entry  ' + plan.cronLine);
+      if (!dry) { const cur = readCron(sh); if (cur !== null) writeCron(sh, cur, plan.cronLine); }
+    } else {
+      log('WARNING: no systemd user session and no crontab here. Add this to your own init/boot script to start the server at boot: ' + cronStartCmd(plan.bin, plan.core, plan.log));
+    }
+    serviceRestart(plan, dry, log, sh, uid);
   } else {
     log('systemctl --user enable --now kenaz-server');
     if (!dry) { sh('systemctl', ['--user', 'daemon-reload']); sh('systemctl', ['--user', 'enable', '--now', 'kenaz-server']); }
+    serviceRestart(plan, dry, log, sh, uid);
   }
 }
-function serviceUninstall(plan, dry, log) {
+function serviceUninstall(plan, dry, log, run = sh) {
   if (plan.kind === 'windows') {
     log('schtasks /End + /Delete /TN ' + TASK_NAME);
-    if (!dry) { sh('schtasks', ['/End', '/TN', TASK_NAME]); sh('schtasks', ['/Delete', '/TN', TASK_NAME, '/F']); }
+    if (!dry) { run('schtasks', ['/End', '/TN', TASK_NAME]); run('schtasks', ['/Delete', '/TN', TASK_NAME, '/F']); }
     if (fs.existsSync(plan.fallbackFile)) { log('remove ' + plan.fallbackFile); if (!dry) fs.rmSync(plan.fallbackFile, { force: true }); }
   } else if (plan.kind === 'launchd') {
-    log('launchctl unload ' + plan.unit); if (!dry) sh('launchctl', ['unload', '-w', plan.unit]);
+    log('launchctl unload ' + plan.unit); if (!dry) run('launchctl', ['unload', '-w', plan.unit]);
+  } else if (plan.kind === 'cron' || plan.kind === 'manual') {
+    if (plan.kind === 'cron') { log('crontab: remove the kenaz-server @reboot entry'); if (!dry) { const cur = readCron(run); if (cur !== null) writeCron(run, cur, null); } }
+    log('stop ' + plan.bin); if (!dry) run('sh', ['-c', stopCmd(plan)]);
   } else {
-    log('systemctl --user disable --now kenaz-server'); if (!dry) sh('systemctl', ['--user', 'disable', '--now', 'kenaz-server']);
+    log('systemctl --user disable --now kenaz-server'); if (!dry) run('systemctl', ['--user', 'disable', '--now', 'kenaz-server']);
   }
   for (const [f] of plan.files) if (fs.existsSync(f)) { log('remove ' + f); if (!dry) fs.rmSync(f, { force: true }); }
 }
-function serviceStatus(plan) {
-  if (plan.kind === 'windows') return sh('schtasks', ['/Query', '/TN', TASK_NAME]).status === 0 ? 'scheduled task present' : (fs.existsSync(plan.fallbackFile) ? 'startup launcher present' : 'not installed');
-  if (plan.kind === 'systemd') return sh('systemctl', ['--user', 'is-active', 'kenaz-server']).stdout.trim() || 'not installed';
+function serviceStatus(plan, run = sh) {
+  if (plan.kind === 'cron') { const c = readCron(run); return c && c.includes(CRON_MARK) ? 'cron @reboot entry present' : 'not installed'; }
+  if (plan.kind === 'manual') return 'manual (no systemd user session, no crontab)';
+  if (plan.kind === 'windows') return run('schtasks', ['/Query', '/TN', TASK_NAME]).status === 0 ? 'scheduled task present' : (fs.existsSync(plan.fallbackFile) ? 'startup launcher present' : 'not installed');
+  if (plan.kind === 'systemd') return run('systemctl', ['--user', 'is-active', 'kenaz-server']).stdout.trim() || 'not installed';
   return fs.existsSync(plan.unit) ? 'plist present' : 'not installed';
 }
 
+/** Which mechanism keeps the server running on this machine (for `kenaz doctor`). Read-only, all via `run`. */
+function detectServiceMode(home, core, run = sh, platform = process.platform) {
+  if (platform === 'win32') {
+    const plan = servicePlan(home, '', core, 'win32');
+    if (run('schtasks', ['/Query', '/TN', TASK_NAME]).status === 0) return { mode: 'windows task', detail: 'scheduled task ' + TASK_NAME };
+    if (fs.existsSync(plan.fallbackFile)) return { mode: 'startup launcher', detail: plan.fallbackFile };
+    return { mode: 'manual', detail: 'no scheduled task or Startup launcher; run `kenaz install`' };
+  }
+  if (platform === 'darwin') {
+    const p = servicePlan(home, '', core, 'darwin').unit;
+    return fs.existsSync(p) ? { mode: 'launchd', detail: p } : { mode: 'manual', detail: 'no launchd agent; run `kenaz install`' };
+  }
+  const unit = servicePlan(home, '', core, 'linux').unit;
+  if (fs.existsSync(unit) && probeLinux(run).systemd) return { mode: 'systemd', detail: unit };
+  const c = readCron(run);
+  if (c && c.includes(CRON_MARK)) return { mode: 'cron', detail: '@reboot crontab entry (no systemd user session)' };
+  return { mode: 'manual', detail: 'no systemd unit or cron entry; run `kenaz install`' };
+}
+
 function parseArgs(argv) {
   const o = { cmd: argv[0], flags: {} };
   for (let i = 1; i < argv.length; i++) {
@@ -217,7 +364,7 @@ function findServerBin(core, home) {
   return c.map((p) => path.resolve(p)).find((p) => fs.existsSync(p)) || null;
 }
 
-function main(argv, out = console.log, getVersion = claudeVersion) { // getVersion: injectable for tests
+function main(argv, out = console.log, getVersion = claudeVersion, deps = {}) { // getVersion, deps {sh, platform, uid, onPlan}: injectable for tests
   const { cmd, flags } = parseArgs(argv);
   if (!['install', 'uninstall', 'status'].includes(cmd)) {
     out('usage: install-kenaz-cli.js <install|uninstall|status> [--dry-run] [--home d] [--core-dir d] [--server-bin p] [--no-service] [--no-plugin]');
@@ -264,11 +411,15 @@ function main(argv, out = console.log, getVersion = claudeVersion) { // getVersi
 
   if (!flags['no-service']) {
     const bin = flags['server-bin'] ? path.resolve(flags['server-bin']) : findServerBin(core, home);
-    const plan = servicePlan(home, bin || '<kenaz-server not found>', core);
-    if (cmd === 'status') out('service: ' + (dry ? 'skipped (dry-run)' : serviceStatus(plan)));
-    else if (cmd === 'uninstall') serviceUninstall(plan, dry, log);
+    const run = deps.sh || sh, platform = deps.platform || process.platform;
+    // the probe is read-only but still a system call: skipped on --dry-run (assumes systemd, as before)
+    const caps = platform === 'linux' && !dry ? probeLinux(run) : undefined;
+    const plan = servicePlan(home, bin || '<kenaz-server not found>', core, platform, caps);
+    if (deps.onPlan) deps.onPlan(plan);
+    if (cmd === 'status') out('service: ' + (dry ? 'skipped (dry-run)' : serviceStatus(plan, run)));
+    else if (cmd === 'uninstall') serviceUninstall(plan, dry, log, run);
     else if (!bin) { out('service: skipped, kenaz-server binary not found (pass --server-bin)'); rc = 1; }
-    else serviceInstall(plan, dry, log);
+    else serviceInstall(plan, dry, log, run, deps.uid);
   }
   if (cmd === 'install' && rc === 0) out('Next: cd <your project>; claude; /kenaz:kenaz init; /kenaz:Ansuz   (Codex: run /hooks once to trust the kenaz hooks, then $kenaz status)');
   if (cmd === 'uninstall') out('Project .kenaz/ data was left untouched.');
@@ -276,4 +427,4 @@ function main(argv, out = console.log, getVersion = claudeVersion) { // getVersi
 }
 
 if (require.main === module) process.exit(main(process.argv.slice(2)));
-module.exports = { main, claudeVersion, loadSettings, entriesOf, norm, MIN_CLI, registerPlugin, unregisterPlugin, retireDashboardHooks, servicePlan, winVbs, launchdPlist, systemdUnit, parseVersion, cmpVersion };
+module.exports = { main, verifyRuntime, healthOnce, serviceInstall, serviceRestart, restartHint, claudeVersion, loadSettings, entriesOf, norm, MIN_CLI, registerPlugin, unregisterPlugin, retireDashboardHooks, servicePlan, detectServiceMode, probeLinux, cronLine, CRON_MARK, winVbs, launchdPlist, systemdUnit, parseVersion, cmpVersion };

package/core/.collaboration/core/task-2264-single-after-capture.test.js

@@ -1,61 +0,0 @@
-// TASK_2264 — completeTask must schedule exactly ONE 'after' health capture.
-// moveTask used to schedule a detached 'after' capture on every ->done move even when
-// completeTask's own postComplete was about to measure the same snapshot.
-// Counting seam: child_process.spawn is patched (task-api requires it at call time) and
-// calls whose inline script carries phase "after" are counted. Isolated temp project.
-// Usage: node .collaboration/core/task-2264-single-after-capture.test.js
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const cp = require('child_process');
-const { TaskAPI, toYAML } = require('./task-api.js');
-
-const SB = fs.mkdtempSync(path.join(os.tmpdir(), 't2264_'));
-const tasksDir = path.join(SB, '.kenaz', 'tasks');
-for (const d of ['backlog', 'active', 'done', 'blocked', 'cancel', 'archived']) fs.mkdirSync(path.join(tasksDir, d), { recursive: true });
-delete process.env.FORMATION_SCHEDULER; delete process.env.FORMATION_HEADLESS;
-
-let pass = 0, fail = 0;
-const check = (n, c, d) => { console.log((c ? 'PASS' : 'FAIL') + ' | ' + n + (c ? '' : ' | ' + d)); c ? pass++ : fail++; };
-
-let phases = [];
-const realSpawn = cp.spawn;
-cp.spawn = function (cmd, argv, opts) {
-  const script = Array.isArray(argv) ? argv.find(a => typeof a === 'string' && a.includes('const CFG')) : null;
-  if (script) {
-    const m = script.match(/"phase":"(before|after)"/);
-    phases.push(m ? m[1] : '?');
-    return { unref() {}, on() {} };
-  }
-  return realSpawn.apply(this, arguments);
-};
-
-const mkActive = (id) => fs.writeFileSync(path.join(tasksDir, 'active', id + '_t.yaml'),
-  toYAML({ id, title: 't2264 ' + id, priority: 'P2', status: 'in_progress' }));
-
-(async () => {
-  const api = new TaskAPI({ tasksDir, projectPath: SB });
-  try {
-    // A: complete with post-complete running in-process (dry run, no git/archive) -> post-complete owns 'after'
-    mkActive('TASK_9001'); phases = [];
-    await api.completeTask('TASK_9001', { dryRun: true, skipGit: true, skipArchive: true });
-    check('A complete w/ post-complete: moveTask schedules NO after capture', phases.filter(p => p === 'after').length === 0, JSON.stringify(phases));
-
-    // B control: post-complete skipped -> nobody else measures, moveTask must still capture exactly once
-    mkActive('TASK_9002'); phases = [];
-    await api.completeTask('TASK_9002', { skipPostComplete: true });
-    check('B control: complete w/ skipPostComplete schedules exactly 1 after capture', phases.filter(p => p === 'after').length === 1, JSON.stringify(phases));
-
-    // C control: bare move done (no post-complete) keeps its single capture
-    mkActive('TASK_9003'); phases = [];
-    await api.moveTask('TASK_9003', 'done');
-    check('C control: bare move done schedules exactly 1 after capture', phases.filter(p => p === 'after').length === 1, JSON.stringify(phases));
-  } catch (e) {
-    check('no exception', false, e && e.stack);
-  } finally {
-    cp.spawn = realSpawn;
-    try { fs.rmSync(SB, { recursive: true, force: true }); } catch { /* best effort */ }
-  }
-  console.log(`\n${pass} passed, ${fail} failed`);
-  process.exit(fail ? 1 : 0);
-})();