tryharness 0.4.1 → 0.4.3

package/lib/parsers.mjs

@@ -1,5 +1,8 @@
-// Fail-open normalizers for the four supported agents. The daemon owns this copy so
-// indexing never depends on a Harness tab or on code downloaded after installation.
+import fs from "node:fs";
+import readline from "node:readline";
+
+// Fail-open normalizers for the four supported agents. JSONL sources are streamed so
+// source-file size never decides which part of a conversation is remembered.
 
 const TITLE_MAX = 120;
 const TOOL_INPUT_CLIP = 100;
@@ -45,71 +48,98 @@ function contentText(content) {
   return parts.join("\n").trim();
 }
 
-function parseClaude(text) {
-  const records = parseLines(text).filter((row) => row.type === "user" || row.type === "assistant");
-  const byId = new Map(records.filter((row) => typeof row.uuid === "string").map((row) => [row.uuid, row]));
+function slimClaude(row) {
+  if (row?.type !== "user" && row?.type !== "assistant") return null;
+  return {
+    type: row.type,
+    uuid: typeof row.uuid === "string" ? row.uuid : null,
+    parentUuid: typeof row.parentUuid === "string" ? row.parentUuid : null,
+    timestamp: typeof row.timestamp === "string" ? row.timestamp : null,
+    cwd: typeof row.cwd === "string" ? row.cwd : null,
+    text: contentText(row.message?.content),
+  };
+}
+
+function finishClaude(records) {
+  const byId = new Map(records.filter((row) => row.uuid).map((row) => [row.uuid, row]));
   const chain = [];
   const seen = new Set();
   let cursor = records.at(-1);
   while (cursor) {
-    if (typeof cursor.uuid === "string") {
+    if (cursor.uuid) {
       if (seen.has(cursor.uuid)) break;
       seen.add(cursor.uuid);
     }
     chain.unshift(cursor);
-    cursor = typeof cursor.parentUuid === "string" ? byId.get(cursor.parentUuid) : undefined;
+    cursor = cursor.parentUuid ? byId.get(cursor.parentUuid) : undefined;
   }
   const source = chain.length >= records.length / 2 ? chain : records;
-  const messages = source.flatMap((row) => {
-    const textValue = contentText(row.message?.content);
-    return textValue ? [{ role: row.type === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null }] : [];
-  });
+  const messages = source.flatMap((row) => row.text ? [{
+    role: row.type === "user" ? "user" : "agent",
+    text: row.text,
+    ts: row.timestamp,
+  }] : []);
   return {
     meta: {
-      cwd: typeof records[0]?.cwd === "string" ? records[0].cwd : null,
-      startedAt: typeof records[0]?.timestamp === "string" ? records[0].timestamp : null,
-      endedAt: typeof records.at(-1)?.timestamp === "string" ? records.at(-1).timestamp : null,
+      cwd: records.find((row) => row.cwd)?.cwd || null,
+      startedAt: records.find((row) => row.timestamp)?.timestamp || null,
+      endedAt: [...records].reverse().find((row) => row.timestamp)?.timestamp || null,
     },
     messages,
   };
 }
 
+function parseClaude(text) {
+  return finishClaude(parseLines(text).map(slimClaude).filter(Boolean));
+}
+
+function finishCodex(meta, messages, startedAt, endedAt) {
+  return {
+    meta: { cwd: typeof meta?.cwd === "string" ? meta.cwd : null, startedAt, endedAt },
+    messages,
+  };
+}
+
 function parseCodex(text) {
-  const records = parseLines(text);
-  const meta = records.find((row) => row.type === "session_meta")?.payload || {};
-  const messages = records.flatMap((row) => {
+  let meta = {};
+  let startedAt = null;
+  let endedAt = null;
+  const messages = [];
+  for (const row of parseLines(text)) {
+    if (row.type === "session_meta" && row.payload && !Object.keys(meta).length) meta = row.payload;
+    if (typeof row.timestamp === "string") {
+      startedAt ||= row.timestamp;
+      endedAt = row.timestamp;
+    }
     const payload = row.type === "response_item" ? row.payload : null;
-    if (!payload || payload.type !== "message") return [];
+    if (!payload || payload.type !== "message") continue;
     const textValue = contentText(payload.content);
-    return textValue ? [{ role: payload.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null }] : [];
-  });
-  const timestamps = records.map((row) => row.timestamp).filter((value) => typeof value === "string");
+    if (textValue) messages.push({ role: payload.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null });
+  }
+  return finishCodex(meta, messages, startedAt, endedAt);
+}
+
+function finishPi(header, messages) {
   return {
     meta: {
-      cwd: typeof meta.cwd === "string" ? meta.cwd : null,
-      startedAt: timestamps[0] || null,
-      endedAt: timestamps.at(-1) || null,
+      cwd: typeof header?.cwd === "string" ? header.cwd : null,
+      startedAt: typeof header?.timestamp === "string" ? header.timestamp : null,
+      endedAt: messages.at(-1)?.ts || null,
     },
     messages,
   };
 }
 
 function parsePi(text) {
-  const records = parseLines(text);
-  const header = records.find((row) => row.type === "session") || {};
-  const messages = records.flatMap((row) => {
-    if (row.type !== "message") return [];
+  let header = {};
+  const messages = [];
+  for (const row of parseLines(text)) {
+    if (row.type === "session" && !Object.keys(header).length) header = row;
+    if (row.type !== "message") continue;
     const textValue = contentText(row.message?.content);
-    return textValue ? [{ role: row.message?.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null }] : [];
-  });
-  return {
-    meta: {
-      cwd: typeof header.cwd === "string" ? header.cwd : null,
-      startedAt: typeof header.timestamp === "string" ? header.timestamp : null,
-      endedAt: messages.at(-1)?.ts || null,
-    },
-    messages,
-  };
+    if (textValue) messages.push({ role: row.message?.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null });
+  }
+  return finishPi(header, messages);
 }
 
 function asIso(value) {
@@ -143,20 +173,74 @@ function parseOpencode(text) {
   };
 }
 
-const PARSERS = { "claude-code": parseClaude, codex: parseCodex, pi: parsePi, opencode: parseOpencode };
+function titleCandidate(message) {
+  if (message.role !== "user") return false;
+  const text = message.text.trim().toLowerCase();
+  if (text.length <= 2 || text.startsWith("[")) return false;
+  return !text.startsWith("<environment_context>")
+    && !text.startsWith("<permissions instructions>")
+    && !text.startsWith("<skills_instructions>");
+}
 
-export function parseSession(agent, raw) {
-  const parser = PARSERS[agent];
-  if (!parser) throw new Error(`unsupported agent: ${agent}`);
-  const { meta, messages } = parser(raw);
-  const firstUser = messages.find((message) => message.role === "user" && !message.text.startsWith("[") && message.text.trim().length > 2)
-    || messages.find((message) => message.role === "user");
+function normalize({ meta, messages }) {
+  const firstUser = messages.find(titleCandidate) || messages.find((message) => message.role === "user");
   return {
     meta: {
       ...meta,
       title: (firstUser?.text || "").replace(/\s+/g, " ").trim().slice(0, TITLE_MAX),
       messageCount: messages.length,
     },
-    transcript: messages.map((message) => `${message.role === "user" ? "User" : "Agent"}: ${message.text}`).join("\n\n").slice(0, 400_000),
+    transcript: messages.map((message) => `${message.role === "user" ? "User" : "Agent"}: ${message.text}`).join("\n\n"),
   };
 }
+
+const PARSERS = { "claude-code": parseClaude, codex: parseCodex, pi: parsePi, opencode: parseOpencode };
+
+export function parseSession(agent, raw) {
+  const parser = PARSERS[agent];
+  if (!parser) throw new Error(`unsupported agent: ${agent}`);
+  return normalize(parser(raw));
+}
+
+export async function parseSessionFile(agent, file) {
+  if (agent === "opencode") return parseSession(agent, await fs.promises.readFile(file, "utf8"));
+  if (!["claude-code", "codex", "pi"].includes(agent)) throw new Error(`unsupported agent: ${agent}`);
+
+  const claudeRecords = [];
+  const messages = [];
+  let codexMeta = {};
+  let piHeader = {};
+  let startedAt = null;
+  let endedAt = null;
+  const input = fs.createReadStream(file, { encoding: "utf8" });
+  const lines = readline.createInterface({ input, crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    let row;
+    try { row = JSON.parse(line); } catch { continue; }
+    if (agent === "claude-code") {
+      const slim = slimClaude(row);
+      if (slim) claudeRecords.push(slim);
+      continue;
+    }
+    if (agent === "codex") {
+      if (row.type === "session_meta" && row.payload && !Object.keys(codexMeta).length) codexMeta = row.payload;
+      if (typeof row.timestamp === "string") {
+        startedAt ||= row.timestamp;
+        endedAt = row.timestamp;
+      }
+      const payload = row.type === "response_item" ? row.payload : null;
+      if (!payload || payload.type !== "message") continue;
+      const textValue = contentText(payload.content);
+      if (textValue) messages.push({ role: payload.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null });
+      continue;
+    }
+    if (row.type === "session" && !Object.keys(piHeader).length) piHeader = row;
+    if (row.type !== "message") continue;
+    const textValue = contentText(row.message?.content);
+    if (textValue) messages.push({ role: row.message?.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null });
+  }
+  if (agent === "claude-code") return normalize(finishClaude(claudeRecords));
+  if (agent === "codex") return normalize(finishCodex(codexMeta, messages, startedAt, endedAt));
+  return normalize(finishPi(piHeader, messages));
+}

package/lib/paths.mjs

@@ -14,6 +14,7 @@ export const paths = {
   status: path.join(harnessHome, "daemon-status.json"),
   socket: process.platform === "win32" ? "\\\\.\\pipe\\tryharness-daemon" : path.join(harnessHome, "daemon.sock"),
   log: path.join(harnessHome, "daemon.log"),
+  runs: path.join(harnessHome, "runs"),
   runtime: path.join(harnessHome, "runtime"),
   legacyBridgeConfig: path.join(harnessHome, "bridge.json"),
   legacySpool: path.join(harnessHome, "pending-sessions.json"),

package/lib/runner.mjs

@@ -1,56 +1,75 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 
 const running = new Set();
 
-function workingDirectory(requested) {
-  const home = os.homedir();
-  const resolved = !requested ? home : requested === "~" ? home : requested.startsWith("~/") ? path.join(home, requested.slice(2)) : requested;
-  return fs.existsSync(resolved) ? resolved : home;
+export function resolveWorkingDirectory(requested) {
+  if (!requested || !path.isAbsolute(requested)) throw new Error("Delegated tasks require an absolute working directory.");
+  let stat;
+  try { stat = fs.statSync(requested); }
+  catch { throw new Error(`Delegated task directory does not exist: ${requested}`); }
+  if (!stat.isDirectory()) throw new Error(`Delegated task working directory is not a directory: ${requested}`);
+  return requested;
 }
 
-export function runAgentTask(task, emit) {
+export function agentInvocation(task) {
+  if (task.agent === "claude-code") {
+    return {
+      command: "claude",
+      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", "--dangerously-skip-permissions", "--name", `Harness: ${task.title}`],
+    };
+  }
+  if (task.agent === "codex") {
+    return {
+      command: "codex",
+      args: ["exec", "--json", "--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check", "-"],
+      stdin: task.brief,
+    };
+  }
+  // Pi has no permission prompts. --approve trusts project-local configuration for
+  // this non-interactive run; its complete built-in tool set remains enabled.
+  if (task.agent === "pi") return { command: "pi", args: ["--mode", "json", "--approve", "-p", task.brief] };
+  if (task.agent === "opencode") {
+    return { command: "opencode", args: ["run", "--format", "json", "--auto", "--title", task.title, "--", task.brief] };
+  }
+  throw new Error(`Unsupported agent: ${task.agent}`);
+}
+
+export function runAgentTask(task, emit, observe = () => {}) {
   if (running.has(task.agent)) {
     emit("failed", `A ${task.agent} task is already running on this machine.`);
     return;
   }
-  running.add(task.agent);
+  let cwd;
+  let invocation;
+  try {
+    cwd = resolveWorkingDirectory(task.cwd);
+    invocation = agentInvocation(task);
+  } catch (error) {
+    emit("failed", error.message);
+    return;
+  }
   emit("accepted");
-  const cwd = workingDirectory(task.cwd);
   let child;
   try {
-    if (task.agent === "claude-code") {
-      child = spawn("claude", ["-p", task.brief, "--output-format", "stream-json", "--verbose", "--permission-mode", "acceptEdits"], { cwd });
-    } else if (task.agent === "codex") {
-      const help = spawnSync("codex", ["exec", "--help"], { encoding: "utf8" });
-      const args = ["exec", "--json", "--sandbox", "workspace-write", "--skip-git-repo-check"];
-      if (String(help.stdout || "").includes("--approve-for-me")) args.push("--approve-for-me");
-      args.push("-");
-      child = spawn("codex", args, { cwd });
-      child.stdin.end(task.brief);
-    } else if (task.agent === "pi") {
-      child = spawn("pi", ["--mode", "json", "-p", task.brief], { cwd });
-    } else if (task.agent === "opencode") {
-      child = spawn("opencode", ["run", "--format", "json", "--title", task.title, "--", task.brief], { cwd });
-    } else {
-      running.delete(task.agent);
-      emit("failed", `Unsupported agent: ${task.agent}`);
-      return;
-    }
+    child = spawn(invocation.command, invocation.args, { cwd });
+    if (invocation.stdin !== undefined) child.stdin.end(invocation.stdin);
   } catch (error) {
     running.delete(task.agent);
     emit("failed", `Could not start ${task.agent}: ${error.message}`);
     return;
   }
+  running.add(task.agent);
 
   let resultText = "";
   let tail = "";
   let buffer = "";
   let sessionReported = false;
   child.stdout?.on("data", (chunk) => {
-    buffer += String(chunk);
+    const raw = String(chunk);
+    observe("stdout", raw);
+    buffer += raw;
     const lines = buffer.split("\n");
     buffer = lines.pop() || "";
     for (const line of lines) {
@@ -76,7 +95,11 @@ export function runAgentTask(task, emit) {
       if (progress?.trim()) emit("progress", progress.trim().slice(0, 200));
     }
   });
-  child.stderr?.on("data", (chunk) => { tail = (tail + "\n" + String(chunk)).slice(-4_000); });
+  child.stderr?.on("data", (chunk) => {
+    const raw = String(chunk);
+    observe("stderr", raw);
+    tail = (tail + "\n" + raw).slice(-4_000);
+  });
   child.on("close", (code) => {
     running.delete(task.agent);
     if (code === 0) emit("done", (resultText || "The run finished; check the repository for its changes.").slice(0, 20_000));

package/lib/service.mjs

@@ -12,12 +12,80 @@ function xml(value) {
   return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
 
-function servicePath() {
-  if (process.platform === "darwin") return path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
-  if (process.platform === "linux") return path.join(os.homedir(), ".config", "systemd", "user", "tryharness-daemon.service");
+const WINDOWS_TASK = "tryharness-daemon";
+
+function servicePath(platform = process.platform, homeDir = os.homedir()) {
+  if (platform === "darwin") return path.join(homeDir, "Library", "LaunchAgents", `${LABEL}.plist`);
+  if (platform === "linux") return path.join(homeDir, ".config", "systemd", "user", "tryharness-daemon.service");
+  if (platform === "win32") return path.join(paths.home, `${WINDOWS_TASK}.xml`);
   return null;
 }
 
+// Windows: a Task Scheduler task in the user's own context, the same job launchd and systemd
+// do elsewhere. It runs at logon, hidden (through a script host, so no console window), with
+// no execution time limit (the default would end the daemon after three days), restarts if
+// the daemon dies, and never runs twice. Creating a task for oneself needs no elevation.
+export function windowsTaskDefinition({ nodePath, entry, user, launcher }) {
+  return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo><Description>Harness local daemon: coding history, the task board and the bridge to Harness.</Description></RegistrationInfo>
+  <Triggers><LogonTrigger><Enabled>true</Enabled><UserId>${xml(user)}</UserId></LogonTrigger></Triggers>
+  <Principals><Principal id="Author"><UserId>${xml(user)}</UserId><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal></Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>true</Hidden>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure><Interval>PT1M</Interval><Count>10</Count></RestartOnFailure>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec><Command>wscript.exe</Command><Arguments>"${xml(launcher)}"</Arguments><WorkingDirectory>${xml(path.win32.dirname(entry))}</WorkingDirectory></Exec>
+  </Actions>
+</Task>
+`;
+}
+
+export function windowsLauncher({ nodePath, entry }) {
+  // WScript.Shell Run with window style 0 starts the daemon with no console window.
+  const quote = (value) => '""' + String(value).replaceAll('"', "") + '""';
+  return `Set shell = CreateObject("WScript.Shell")\r\nshell.Run "${quote(nodePath)} ${quote(entry)} daemon", 0, False\r\n`;
+}
+
+function windowsUser(env = process.env) {
+  return env.USERDOMAIN && env.USERNAME ? `${env.USERDOMAIN}\\${env.USERNAME}` : env.USERNAME || os.userInfo().username;
+}
+
+export function installWindowsTask({ runtimeRoot, nodePath = process.execPath, execute = run, env = process.env }) {
+  ensureDir(paths.home);
+  const entry = path.join(runtimeRoot, "cli.mjs");
+  const launcher = path.join(paths.home, `${WINDOWS_TASK}.vbs`);
+  const definition = path.join(paths.home, `${WINDOWS_TASK}.xml`);
+  fs.writeFileSync(launcher, windowsLauncher({ nodePath, entry }));
+  // schtasks reads task XML as UTF-16 with a byte order mark.
+  fs.writeFileSync(definition, "\ufeff" + windowsTaskDefinition({ nodePath, entry, user: windowsUser(env), launcher }), "utf16le");
+  const created = execute("schtasks", ["/Create", "/TN", WINDOWS_TASK, "/XML", definition, "/F"]);
+  if (!created.ok) throw new Error(`could not register the Harness daemon with Task Scheduler: ${created.stderr || created.stdout || created.error}`);
+  execute("schtasks", ["/End", "/TN", WINDOWS_TASK]);
+  const started = execute("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
+  if (!started.ok) throw new Error(`the Harness daemon task was registered but did not start: ${started.stderr || started.stdout || started.error}`);
+  return { manager: "task-scheduler", file: definition };
+}
+
+export function uninstallWindowsTask({ execute = run } = {}) {
+  execute("schtasks", ["/End", "/TN", WINDOWS_TASK]);
+  execute("schtasks", ["/Delete", "/TN", WINDOWS_TASK, "/F"]);
+  for (const file of [path.join(paths.home, `${WINDOWS_TASK}.xml`), path.join(paths.home, `${WINDOWS_TASK}.vbs`)]) {
+    try { fs.unlinkSync(file); } catch {}
+  }
+}
+
 function agentPath() {
   const dirs = new Set([path.dirname(process.execPath), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"]);
   for (const command of ["claude", "codex", "pi", "opencode"]) {
@@ -41,12 +109,13 @@ function retireLegacyBridge() {
   }
 }
 
-export function installService({ runtimeRoot, nodePath = process.execPath }) {
+export function installService({ runtimeRoot, nodePath = process.execPath, platform = process.platform, execute = run }) {
   ensureDir(paths.home);
   retireLegacyBridge();
   const entry = path.join(runtimeRoot, "cli.mjs");
   const envPath = agentPath();
-  if (process.platform === "darwin") {
+  if (platform === "win32") return installWindowsTask({ runtimeRoot, nodePath, execute });
+  if (platform === "darwin") {
     const plist = servicePath();
     ensureDir(path.dirname(plist));
     fs.writeFileSync(plist, `<?xml version="1.0" encoding="UTF-8"?>
@@ -65,7 +134,7 @@ export function installService({ runtimeRoot, nodePath = process.execPath }) {
     run("launchctl", ["kickstart", "-k", `${domain}/${LABEL}`]);
     return { manager: "launchd", file: plist };
   }
-  if (process.platform === "linux") {
+  if (platform === "linux") {
     const unit = servicePath();
     ensureDir(path.dirname(unit));
     fs.writeFileSync(unit, `[Unit]\nDescription=Harness local daemon\nAfter=network-online.target\n\n[Service]\nExecStart=${JSON.stringify(nodePath)} ${JSON.stringify(entry)} daemon\nEnvironment=PATH=${envPath}\nRestart=always\nRestartSec=5\nStandardOutput=append:${paths.log}\nStandardError=append:${paths.log}\n\n[Install]\nWantedBy=default.target\n`, { mode: 0o600 });
@@ -74,26 +143,32 @@ export function installService({ runtimeRoot, nodePath = process.execPath }) {
     if (!reload.ok || !started.ok) throw new Error(`could not start Harness daemon with systemd: ${started.stderr || reload.stderr}`);
     return { manager: "systemd", file: unit };
   }
-  // Windows and other Node platforms still get a ready daemon immediately. `doctor`
-  // reports that login persistence is unavailable rather than pretending it was set.
+  // Other Node platforms get a ready daemon for this login only. `doctor` reports that
+  // login persistence is unavailable rather than pretending it was set.
   const child = spawn(nodePath, [entry, "daemon"], { detached: true, stdio: "ignore", env: { ...process.env, PATH: envPath } });
   child.unref();
   return { manager: "detached", file: null };
 }
 
-export function uninstallService() {
-  const file = servicePath();
-  if (process.platform === "darwin" && file) {
+export function uninstallService({ platform = process.platform, execute = run } = {}) {
+  const file = servicePath(platform);
+  if (platform === "win32") { uninstallWindowsTask({ execute }); return; }
+  if (platform === "darwin" && file) {
     run("launchctl", ["bootout", `gui/${process.getuid()}`, file]);
     try { fs.unlinkSync(file); } catch {}
-  } else if (process.platform === "linux" && file) {
+  } else if (platform === "linux" && file) {
     run("systemctl", ["--user", "disable", "--now", "tryharness-daemon.service"]);
     try { fs.unlinkSync(file); } catch {}
     run("systemctl", ["--user", "daemon-reload"]);
   }
 }
 
-export function serviceInfo() {
-  const file = servicePath();
-  return { manager: process.platform === "darwin" ? "launchd" : process.platform === "linux" ? "systemd" : "detached", installed: Boolean(file && fs.existsSync(file)), file };
+export function serviceInfo({ platform = process.platform, execute = run } = {}) {
+  const file = servicePath(platform);
+  if (platform === "win32") {
+    // Installed means the task is registered, not merely that its files exist.
+    const registered = Boolean(file && fs.existsSync(file)) && execute("schtasks", ["/Query", "/TN", WINDOWS_TASK]).ok;
+    return { manager: "task-scheduler", installed: registered, file };
+  }
+  return { manager: platform === "darwin" ? "launchd" : platform === "linux" ? "systemd" : "detached", installed: Boolean(file && fs.existsSync(file)), file };
 }