goosetools-worker 0.2.3 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goosetools-worker",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "The Goose Tools carousel worker — your computer drafts and renders carousel slides for goosetools.com using your own Claude account.",
   "repository": {
     "type": "git",
@@ -13,7 +13,8 @@
     "styles/polka-dot",
     "carousels/demo/slides.yml",
     "brand.yml",
-    "README.md"
+    "README.md",
+    "skills"
   ],
   "type": "module",
   "bin": {
@@ -25,7 +26,8 @@
   "scripts": {
     "render": "node src/render.js",
     "demo": "node src/render.js carousels/demo",
-    "worker": "node worker/index.js"
+    "worker": "node worker/index.js",
+    "prepublishOnly": "node ../sync-shared.mjs --check"
   },
   "dependencies": {
     "@vercel/blob": "^0.27.0",

package/skills/reference-analysis.md

@@ -0,0 +1,149 @@
+# Reference Analysis Methodology
+
+How to study a set of reference images, map them onto something new, and check
+the finished render against them. Shared by the Carousel Maker (slides) and the
+Overlay Factory (overlays on reels) — the reference images are the source of
+truth for EVERY behavior described here; there are no hardcoded rules. Worker
+prompts splice individual sections by the SECTION markers below.
+
+SHARED FILE: the source of truth is workers/shared/reference-analysis.md in the
+goosetools repo, copied into each worker's skills/ by `npm run workers:sync`.
+
+<!-- SECTION: principles -->
+## Principles — both tools
+
+- **Purpose first, paint second.** Work out what each reference is FOR — the
+  recurring format a follower would recognize — before its colours and fonts.
+  A copy that nails the palette but misses the format is wrong.
+- **Variance vs constants.** Across the set, note what varies and what never
+  changes. Freedom lives exactly where the references vary; fidelity is owed
+  everywhere they don't.
+- **Same-account test.** The finished thing should read as the same account's
+  work if posted next to the references — same format, same typographic
+  voice, same palette logic. Pixel-matching any one reference is NOT the goal.
+- **Look, don't assume.** Read every image before deciding anything, and judge
+  your own output by looking at the render, not by re-reading your markup.
+
+<!-- SECTION: analyze -->
+## Phase A — understand what each reference is DOING
+
+Read every reference image first. For each one, work out:
+
+- **Role**: is this the cover (the hook slide), a middle content slide, or
+  the closer/CTA? The first reference is usually the cover; use layout and
+  copy cues (page counters, "swipe", "follow") to confirm.
+- **Content job**: what is the slide FOR? Presenting a color palette with
+  labeled swatches? Comparing a before vs an after? Listing tips? Showcasing
+  a product photo? The recurring format a follower would recognize is the
+  thing to reproduce — purpose first, paint second.
+- **Photo and subject**: where does the photo's main subject sit in the
+  frame? How tight is the crop?
+- **Overlays**: where do overlays (swatch stacks, badges, labels, text
+  blocks) sit relative to the subject? Record which behavior this set uses:
+  some styles keep overlays OFF the subject (overlays live in the empty
+  side of the frame); others deliberately lay elements OVER the photo as
+  part of the look. Both are legitimate — copy whichever these references do.
+- **Variance vs constants**: across the whole set, what varies (number of
+  swatches, which side the overlay sits on, crop tightness) and what never
+  changes (the format, the typography, the palette treatment, the border
+  style)? Freedom lives exactly where the references vary; fidelity is owed
+  everywhere they don't.
+
+<!-- SECTION: map -->
+## Phase B — map references onto the new carousel, role to role
+
+Match by ROLE and FORMAT, never image-to-image: your cover should do what
+the reference cover does, your closer what their closer does, and every
+middle slide should follow the references' middle-slide format. Your slide 3
+does not need to mirror reference slide 3.
+
+- **Colors**: if the user's photos share a coherent palette (e.g. they are
+  all sunsets, all one product line), sample the carousel's colors from THE
+  USER'S PHOTOS so the deck feels made from their images. If the photos are
+  visually unrelated, keep the references' original colors. Never mix in
+  colors from anywhere else.
+- **Variance**: whatever varied across the references may vary across your
+  slides the same way — swatch counts, overlay side, crop tightness. Do not
+  make every slide identical when the references weren't.
+- **Overlay placement**: follow the coverage behavior recorded in Phase A.
+  If the references keep overlays clear of the subject, look at each of the
+  user's photos (and what the user's prompt says the photo is about) and
+  place overlays on the empty side — use `variant: flip` on a slide to
+  mirror a template's overlay to the other side. If the references overlay
+  the photo deliberately, do the same.
+- **Photo count adaptation** — the references decide the slide mix:
+  - More photos than slides: choose the photos that best serve each slide's
+    message, but if the user's prompt asks to show something specific, the
+    photo showing it MUST be used.
+  - Fewer photos than the format wants: if the references put a photo on
+    every slide, reuse a photo with a DIFFERENT focus/zoom crop so it reads
+    as a new frame; if the references include photo-free formats (statement
+    slides, text slides), use those instead. Never pad with invented filler
+    content.
+
+<!-- SECTION: compare -->
+## Phase C — compare each rendered slide against the references
+
+For each rendered slide, find the reference(s) with the same ROLE (slide 1 =
+cover, last slide = CTA/closer, everything else = middle) and ask:
+
+- **Same-account test**: if this slide were posted next to the references,
+  would it read as the same account's work — same format, same typographic
+  voice, same palette logic? Exact alignment with any single reference is
+  NOT required; matching the format is.
+- **Overlay-behavior test**: does the slide follow the references' coverage
+  behavior? If they keep overlays off the subject, is this slide's subject
+  (or a face) hidden under a swatch stack, badge, or caption? If so it
+  fails — fix with `variant: flip` (mirror the overlay side) or a focus/zoom
+  change that moves the subject clear.
+- **Framing test**: is the thing the slide is about actually prominent and
+  centered by the crop, exactly as the reference format frames its subjects?
+
+Fix vocabulary (per slide): `focus` ("X% Y%" on the original photo),
+`zoom` (1–3), `variant: flip` (mirror the overlay side), `swatches`
+(recount/recolor a swatch list — only on slides that already have one).
+Never rewrite a slide's text or switch its template during comparison.
+
+<!-- SECTION: overlay-analyze -->
+## Overlay Phase A — understand what the references are DOING
+
+These are frames from reels (or screenshots of them) with text or graphics laid
+over footage. For the set, work out:
+
+- **Format**: what one episode of this is — a question, a hot take, a stat, a
+  quote, a before/after label? That is what the fields should capture.
+- **Hierarchy**: what the eye reads first, second, third, and how that is
+  achieved (size, weight, colour, a box, a bar, a label above the main line).
+- **Type**: weight, case, letter-spacing, serif vs sans vs mono, line length,
+  how many lines the main text runs to.
+- **Containers**: solid box, translucent scrim, outline, shadow only, or text
+  straight on footage — and corner radius, border, padding.
+- **Placement**: where on the 9:16 frame each element sits, and how much of
+  the frame the overlay takes. Note anything placed where Instagram's UI would
+  cover it — keep the format but move it into the safe band.
+- **Colour logic**: which colours are fixed accents and which come from the
+  footage; how contrast is kept over busy or bright video.
+- **Variance vs constants** across the set (see Principles).
+
+<!-- SECTION: overlay-compare -->
+## Overlay Phase C — compare the rendered frame against the references
+
+Look at the rendered frame (sample text in every field, over grey) next to the
+references and ask:
+
+- **Same-account test**: would this sit next to the references as the same
+  series? Same format, hierarchy, type treatment, container style, colour
+  logic.
+- **Hierarchy test**: does the eye land where it lands in the references, in
+  the same order?
+- **Proportion test**: is the overlay roughly the size the references use — not
+  a tiny label where they fill the band, not a slab where they are a caption?
+- **Legibility test**: would it read over ANY footage, on a phone at arm's
+  length? Thin text straight on video fails.
+- **Safe-area test**: is anything in Instagram's top bar, right action rail or
+  bottom caption zone?
+
+Fix by editing the templates (sizes, weights, spacing, colours, containers,
+widthPct, anchor). Never change field keys, the content brief, or wording that
+the user typed or asked for.
+

package/worker/agent-cli.js

@@ -1,9 +1,11 @@
 // Agent CLI adapter — runs a job's prompt through whichever coding-agent CLI
 // the user picked on goosetools.com (claim payloads carry `agentCli`).
 //
-// VENDORED FILE: keep byte-identical across brand-manager-worker,
-// caption-maker, and carousel-maker (worker/agent-cli.js in each). Fix a bug
-// here, copy it to the other two.
+// SHARED FILE: the source of truth is workers/shared/agent-cli.js in the
+// goosetools repo. Each worker ships its own copy (worker/agent-cli.js) so the
+// npm packages stay self-contained. Edit the shared one, then run
+// `npm run workers:sync` from the repo root; `npm run workers:check` fails if
+// a copy has drifted.
 //
 // Modes, chosen for speed-vs-capability (see brand-manager commit c0c1b33 —
 // tool-looping turned 36-second drafts into 10-minute ones):

package/worker/cli-core.js

@@ -0,0 +1,88 @@
+// SHARED FILE: the source of truth is workers/shared/cli-core.js in the
+// goosetools repo; each worker ships a copy as worker/cli-core.js. Edit the
+// shared one, then `npm run workers:sync`.
+//
+// The command-line entrypoint every worker shares. Each worker's
+// worker/cli.js (its npm `bin`) is a few lines calling runCli().
+//
+//   install    save token + register a login service (worker runs forever)
+//   update     pull the newest code into the background copy + restart
+//   status     what's installed, whether it's running, recent log lines
+//   uninstall  remove the service (the shared token stays)
+//   doctor     which coding-agent CLIs are installed
+//   run        run the worker loop in this window (default)
+
+import { execSync } from "node:child_process";
+
+const COMMANDS = ["install", "update", "status", "uninstall", "run", "doctor"];
+
+function flag(name) {
+  const i = process.argv.indexOf(name);
+  return i !== -1 ? process.argv[i + 1] : undefined;
+}
+
+function has(cmd) {
+  try {
+    execSync(process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`, {
+      stdio: "ignore",
+      shell: true,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {object} opts
+ * @param {string} opts.root                  the package root (parent of worker/)
+ * @param {string} opts.writes                finishes "Claude Code isn't installed yet (it writes …)"
+ * @param {() => Promise<{install, update, uninstall, status}>} opts.service  loads worker/service.js
+ * @param {() => Promise<unknown>} opts.worker                                 loads worker/index.js
+ * @param {() => void} [opts.preflight]       extra setup before install/update/run (e.g. a browser)
+ */
+export async function runCli({ root, writes, service, worker, preflight }) {
+  const command = COMMANDS.includes(process.argv[2]) ? process.argv[2] : "run";
+
+  // These only inspect or tear down what's already there, so they skip the
+  // preflight below — `status` in particular has to work precisely when
+  // something IS wrong.
+  if (command === "uninstall") return (await service()).uninstall();
+  if (command === "status") return (await service()).status();
+
+  // Claude Code is the default agent, so it's required to set up; the other
+  // agents (picked in Setup on goosetools.com) are checked lazily per job and
+  // reported here.
+  if (command === "doctor") {
+    const { AGENT_IDS, detect } = await import("./agent-cli.js");
+    for (const id of AGENT_IDS) {
+      const d = detect(id);
+      console.log(`${d.installed ? "✓" : "✗"} ${d.label}${d.installed ? "" : `  — install: ${d.hint}`}`);
+    }
+    return;
+  }
+
+  if (!has("claude")) {
+    console.error(
+      `\nClaude Code isn't installed yet (it writes ${writes}).\n` +
+        "Install it with:  npm install -g @anthropic-ai/claude-code\n" +
+        "Then run:         claude   (once, to sign in — type /exit to leave)\n" +
+        "Then run this command again.\n",
+    );
+    process.exit(1);
+  }
+
+  preflight?.();
+
+  if (command === "install") {
+    // No --url means "keep the saved server, else goosetools.com" — decided in
+    // install(), which can see the saved one.
+    return (await service()).install({
+      url: flag("--url")?.replace(/\/$/, ""),
+      token: flag("--token"),
+      root,
+    });
+  }
+  if (command === "update") return (await service()).update({ root });
+  await worker();
+}

package/worker/cli.js

@@ -1,124 +1,56 @@
 #!/usr/bin/env node
-// goosetools-worker entrypoint — makes first run painless for non-technical
-// users: checks for Claude Code + the Playwright browser, installs the
-// browser if missing, then runs the requested command.
-//
-//   install    save token + register a login service (worker runs forever)
-//   update     pull the newest code into the background copy + restart
-//   status     what's installed, whether it's running, recent log lines
-//   uninstall  remove the service + saved token
-//   run        run the worker loop in this window (default)
+// goosetools-worker (Carousel Maker) entrypoint. The commands live in
+// worker/cli-core.js (shared by every worker); this adds the one thing
+// carousels need first: the Playwright browser that renders slides, installed
+// if missing so first run is painless for non-technical users.
 
-import { execFileSync, execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { runCli } from "./cli-core.js";
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
-const command = ["install", "update", "status", "uninstall", "run", "doctor"].includes(process.argv[2])
-  ? process.argv[2]
-  : "run";
-
-// These two only inspect or tear down what's already there, so they skip the
-// Claude Code / browser preflight below — `status` in particular has to work
-// precisely when something IS wrong.
-if (command === "uninstall") {
-  const { uninstall } = await import("./service.js");
-  uninstall();
-  process.exit(0);
-}
-
-if (command === "status") {
-  const { status } = await import("./service.js");
-  status();
-  process.exit(0);
-}
-
-function flag(name) {
-  const i = process.argv.indexOf(name);
-  return i !== -1 ? process.argv[i + 1] : undefined;
-}
-
-function has(cmd) {
+// Make sure the rendering browser is present (quiet no-op when it is).
+function ensureBrowser() {
+  // Run the playwright CLI that ships with our own dependencies via node —
+  // going through `npx playwright` instead prints a scary warning box.
   try {
-    execSync(process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`, {
-      stdio: "ignore",
-      shell: true,
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Claude Code is the default agent, so it's required to set up; the other
-// agents (picked in Setup on goosetools.com) are checked lazily per job and
-// reported by `doctor`.
-if (command === "doctor") {
-  const { AGENT_IDS, detect } = await import("./agent-cli.js");
-  for (const id of AGENT_IDS) {
-    const d = detect(id);
-    console.log(
-      `${d.installed ? "✓" : "✗"} ${d.label}${d.installed ? "" : `  — install: ${d.hint}`}`,
+    console.log("Checking the rendering browser (first run can take a minute)…");
+    const require = createRequire(join(ROOT, "package.json"));
+    const playwrightCli = join(
+      dirname(require.resolve("playwright/package.json")),
+      "cli.js",
     );
+    if (existsSync(playwrightCli)) {
+      // Quiet on success — playwright's CLI prints a misleading "run npm
+      // install first" box in the npx cache layout. Its output is only shown
+      // (via the catch below) when the install genuinely fails.
+      execFileSync(process.execPath, [playwrightCli, "install", "chromium"], {
+        cwd: ROOT,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } else {
+      execFileSync("npx", ["--yes", "playwright", "install", "chromium"], {
+        cwd: ROOT,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+      });
+    }
+  } catch (err) {
+    const detail = err?.stderr?.toString().trim();
+    if (detail) console.error(detail);
+    console.error("Couldn't install the rendering browser — check your internet connection and retry.");
+    process.exit(1);
   }
-  process.exit(0);
 }
 
-if (!has("claude")) {
-  console.error(
-    "\nClaude Code isn't installed yet (it writes your slides).\n" +
-      "Install it with:  npm install -g @anthropic-ai/claude-code\n" +
-      "Then run:         claude   (once, to sign in — type /exit to leave)\n" +
-      "Then run this command again.\n",
-  );
-  process.exit(1);
-}
-
-// Make sure the rendering browser is present (quiet no-op when it is).
-// Run the playwright CLI that ships with our own dependencies via node —
-// going through `npx playwright` instead prints a scary warning box.
-try {
-  console.log("Checking the rendering browser (first run can take a minute)…");
-  const require = createRequire(join(ROOT, "package.json"));
-  const playwrightCli = join(
-    dirname(require.resolve("playwright/package.json")),
-    "cli.js",
-  );
-  if (existsSync(playwrightCli)) {
-    // Quiet on success — playwright's CLI prints a misleading "run npm
-    // install first" box in the npx cache layout. Its output is only shown
-    // (via the catch below) when the install genuinely fails.
-    execFileSync(process.execPath, [playwrightCli, "install", "chromium"], {
-      cwd: ROOT,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-  } else {
-    execFileSync("npx", ["--yes", "playwright", "install", "chromium"], {
-      cwd: ROOT,
-      stdio: "inherit",
-      shell: process.platform === "win32",
-    });
-  }
-} catch (err) {
-  const detail = err?.stderr?.toString().trim();
-  if (detail) console.error(detail);
-  console.error("Couldn't install the rendering browser — check your internet connection and retry.");
-  process.exit(1);
-}
-
-if (command === "install") {
-  const { install } = await import("./service.js");
-  install({
-    url: (flag("--url") ?? "https://goosetools.com").replace(/\/$/, ""),
-    token: flag("--token"),
-    root: ROOT,
-  });
-} else if (command === "update") {
-  const { update } = await import("./service.js");
-  update({ root: ROOT });
-} else {
-  await import("./index.js");
-}
+await runCli({
+  root: ROOT,
+  writes: "your slides",
+  service: () => import("./service.js"),
+  worker: () => import("./index.js"),
+  preflight: ensureBrowser,
+});

package/worker/service-core.js

@@ -0,0 +1,411 @@
+// SHARED FILE: the source of truth is workers/shared/service-core.js in the
+// goosetools repo; each worker ships a copy as worker/service-core.js. Edit the
+// shared one, then `npm run workers:sync`.
+//
+// Background-service install/uninstall for a Goose Tools worker. Each worker's
+// own worker/service.js is a thin config around this (package name, service
+// label, log paths, wording), so the three can't drift apart again.
+//
+// `install` makes the worker persistent: token saved to ~/.goosetools/env, a
+// stable copy of the package installed under ~/.goosetools/<appDir>, and a
+// login service registered (launchd LaunchAgent on macOS, a logon Scheduled
+// Task on Windows) so the worker runs whenever the computer is on — no
+// terminal window needed. `update` re-runs that install against the newest
+// code, reusing the saved token; `status` reports what's actually running.
+//
+// The worker TOKEN is shared: every worker reads ~/.goosetools/env, so a
+// computer already connected for one tool needs no --token for the next.
+//
+// Service labels, app dirs and log names are per worker and must never change:
+// an update re-registers the service under the same name, which is what
+// replaces the old one on machines that already have it.
+
+import { execSync } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export const GOOSE_DIR = join(homedir(), ".goosetools");
+const ENV_FILE = join(GOOSE_DIR, "env");
+const DEFAULT_URL = "https://goosetools.com";
+
+function sh(cmd, opts = {}) {
+  return execSync(cmd, { stdio: ["ignore", "pipe", "pipe"], ...opts })
+    .toString()
+    .trim();
+}
+
+export function quietSh(cmd) {
+  try {
+    sh(cmd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function npmGlobalBin() {
+  try {
+    const prefix = sh("npm prefix -g", { shell: true });
+    return process.platform === "win32" ? prefix : join(prefix, "bin");
+  } catch {
+    return "";
+  }
+}
+
+// Everything the daemon needs to find: node itself, the npm-global bin (where
+// `claude` lives), plus the usual suspects.
+function servicePath() {
+  const parts = [
+    dirname(process.execPath),
+    npmGlobalBin(),
+    ...(process.platform === "win32"
+      ? [process.env.PATH ?? ""]
+      : [
+          "/opt/homebrew/bin",
+          "/usr/local/bin",
+          // opencode's installer and some npm setups drop binaries here.
+          `${process.env.HOME ?? ""}/.local/bin`,
+          "/usr/bin",
+          "/bin",
+          "/usr/sbin",
+          "/sbin",
+        ]),
+  ].filter(Boolean);
+  return [...new Set(parts)].join(process.platform === "win32" ? ";" : ":");
+}
+
+function readEnvFile() {
+  if (!existsSync(ENV_FILE)) return {};
+  return Object.fromEntries(
+    readFileSync(ENV_FILE, "utf8")
+      .split("\n")
+      .filter((l) => l.includes("=") && !l.trim().startsWith("#"))
+      .map((l) => [l.slice(0, l.indexOf("=")).trim(), l.slice(l.indexOf("=") + 1).trim()]),
+  );
+}
+
+function writeEnvFile({ url, token }) {
+  mkdirSync(GOOSE_DIR, { recursive: true });
+  writeFileSync(ENV_FILE, `GOOSETOOLS_URL=${url}\nWORKER_TOKEN=${token}\n`);
+  chmodSync(ENV_FILE, 0o600);
+}
+
+function compareVersions(a, b) {
+  // -1 / 0 / 1, comparing x.y.z numerically. Anything unparseable sorts equal
+  // so an odd version string never nags the user to "update" in a loop.
+  const parts = (v) => String(v).split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const [pa, pb] = [parts(a), parts(b)];
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) < (pb[i] ?? 0) ? -1 : 1;
+  }
+  return 0;
+}
+
+function tail(file, n) {
+  try {
+    return readFileSync(file, "utf8").trimEnd().split("\n").slice(-n).join("\n");
+  } catch {
+    return "";
+  }
+}
+
+// How long ago a log was last written. Without this, days-old errors read as a
+// live outage — the single most misleading thing in a log tail.
+function lastWritten(file) {
+  try {
+    const ms = Date.now() - statSync(file).mtimeMs;
+    const mins = Math.round(ms / 60000);
+    if (mins < 1) return "just now";
+    if (mins < 60) return `${mins} min ago`;
+    const hours = Math.round(mins / 60);
+    if (hours < 24) return `${hours} hr ago`;
+    return `${Math.round(hours / 24)} days ago`;
+  } catch {
+    return "unknown";
+  }
+}
+
+/**
+ * @param {object} cfg
+ * @param {string} cfg.pkg          npm package name, e.g. "caption-maker-worker"
+ * @param {string} cfg.name         for messages, e.g. "Caption worker"
+ * @param {string} cfg.appDir       background copy under ~/.goosetools, e.g. "caption-app"
+ * @param {string} cfg.macLabel     launchd label, e.g. "com.goosetools.caption"
+ * @param {string} cfg.winTask      Scheduled Task name
+ * @param {string} cfg.winVbs       launcher file name under ~/.goosetools
+ * @param {string} cfg.logName      log file name under ~/.goosetools (".log" / ".err.log" appended)
+ * @param {string} cfg.dashboard    where a token comes from, e.g. "/dashboard/caption"
+ * @param {string} cfg.doing        finishes "This computer now …", e.g. "writes your captions"
+ * @param {() => string | void} [cfg.afterInstall]  extra lines printed after a successful install
+ * @param {() => string[]} [cfg.statusLines]        extra "  ✓ Label   value" rows for status
+ */
+export function createService(cfg) {
+  const APP_PREFIX = join(GOOSE_DIR, cfg.appDir);
+  const INSTALLED_CLI = join(APP_PREFIX, "node_modules", cfg.pkg, "worker", "cli.js");
+  const MAC_PLIST = join(homedir(), "Library", "LaunchAgents", `${cfg.macLabel}.plist`);
+  const WIN_VBS = join(GOOSE_DIR, cfg.winVbs);
+  const LOG_FILE = join(GOOSE_DIR, `${cfg.logName}.log`);
+  const ERR_FILE = join(GOOSE_DIR, `${cfg.logName}.err.log`);
+  const connectHint =
+    `Get a token at ${DEFAULT_URL}${cfg.dashboard} (any tool — same token), then run:\n` +
+    `  npx --yes ${cfg.pkg}@latest install --token gt_…`;
+
+  function installStableCopy(root) {
+    console.log("Setting up the background copy (this can take a minute)…");
+    mkdirSync(APP_PREFIX, { recursive: true });
+    // From a git checkout (development), install the checkout itself; normal
+    // npx users get the published package.
+    const source = isCheckout(root) ? `"${root}"` : `${cfg.pkg}@latest`;
+    execSync(`npm install --no-fund --no-audit --loglevel=error --prefix "${APP_PREFIX}" ${source}`, {
+      stdio: ["ignore", "inherit", "inherit"],
+      shell: true,
+    });
+    if (!existsSync(INSTALLED_CLI)) {
+      throw new Error("background copy did not install where expected");
+    }
+  }
+
+  // ── macOS (launchd) ────────────────────────────────────────────────────────
+
+  function macPlist() {
+    const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${cfg.macLabel}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${esc(process.execPath)}</string>
+        <string>${esc(INSTALLED_CLI)}</string>
+        <string>run</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
+    <key>StandardOutPath</key>
+    <string>${esc(LOG_FILE)}</string>
+    <key>StandardErrorPath</key>
+    <string>${esc(ERR_FILE)}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${esc(servicePath())}</string>
+    </dict>
+</dict>
+</plist>
+`;
+  }
+
+  function macInstall() {
+    mkdirSync(dirname(MAC_PLIST), { recursive: true });
+    writeFileSync(MAC_PLIST, macPlist());
+    const uid = process.getuid();
+    // Re-registering: tear down any previous copy first, then bootstrap.
+    quietSh(`launchctl bootout gui/${uid}/${cfg.macLabel}`);
+    if (!quietSh(`launchctl bootstrap gui/${uid} "${MAC_PLIST}"`)) {
+      // Older macOS fallback.
+      quietSh(`launchctl unload "${MAC_PLIST}"`);
+      execSync(`launchctl load -w "${MAC_PLIST}"`, { stdio: "ignore" });
+    }
+  }
+
+  function macUninstall() {
+    quietSh(`launchctl bootout gui/${process.getuid()}/${cfg.macLabel}`);
+    quietSh(`launchctl unload "${MAC_PLIST}"`);
+    rmSync(MAC_PLIST, { force: true });
+  }
+
+  // ── Windows (Scheduled Task at logon, hidden window) ───────────────────────
+
+  function winInstall() {
+    // wscript launches the worker with no console window.
+    const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${INSTALLED_CLI}"" run", 0, False\r\n`;
+    writeFileSync(WIN_VBS, vbs);
+    quietSh(`schtasks /End /TN "${cfg.winTask}"`);
+    quietSh(`schtasks /Delete /F /TN "${cfg.winTask}"`);
+    execSync(`schtasks /Create /F /SC ONLOGON /TN "${cfg.winTask}" /TR "wscript.exe \\"${WIN_VBS}\\""`, {
+      stdio: "ignore",
+      shell: true,
+    });
+    execSync(`schtasks /Run /TN "${cfg.winTask}"`, { stdio: "ignore", shell: true });
+  }
+
+  function winUninstall() {
+    quietSh(`schtasks /End /TN "${cfg.winTask}"`);
+    quietSh(`schtasks /Delete /F /TN "${cfg.winTask}"`);
+    rmSync(WIN_VBS, { force: true });
+  }
+
+  function registerService() {
+    if (process.platform === "darwin") macInstall();
+    else if (process.platform === "win32") winInstall();
+    else {
+      console.error(
+        "Automatic background setup isn't available on this OS yet.\n" +
+          `Run the worker directly instead:  ${cfg.pkg} run`,
+      );
+      process.exit(1);
+    }
+  }
+
+  function installedVersion() {
+    try {
+      const pkg = join(APP_PREFIX, "node_modules", cfg.pkg, "package.json");
+      return JSON.parse(readFileSync(pkg, "utf8")).version ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  function latestVersion() {
+    try {
+      return sh(`npm view ${cfg.pkg} version`, { shell: true, timeout: 15000 });
+    } catch {
+      return null; // offline, or npm unreachable — not an error worth failing on
+    }
+  }
+
+  // launchctl prints "<pid>\t<last exit>\t<label>"; a "-" pid means registered
+  // but not currently running.
+  function servicePid() {
+    try {
+      if (process.platform === "darwin") {
+        const line = sh(`launchctl list | grep ${cfg.macLabel}`, { shell: true });
+        const pid = line.split(/\s+/)[0];
+        return pid === "-" ? null : pid;
+      }
+      const out = sh(`schtasks /Query /TN "${cfg.winTask}" /FO LIST`, { shell: true });
+      return /Running/i.test(out) ? "running" : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // ── Public commands ────────────────────────────────────────────────────────
+
+  function install({ url, token, root }) {
+    // Reuse the saved token and server when the caller didn't pass them — a
+    // computer already connected for another tool.
+    const saved = readEnvFile();
+    const effectiveToken = token ?? saved.WORKER_TOKEN;
+    const effectiveUrl = url ?? saved.GOOSETOOLS_URL ?? DEFAULT_URL;
+    if (!effectiveToken) {
+      console.error(`No worker token found. ${connectHint}`);
+      process.exit(1);
+    }
+    writeEnvFile({ url: effectiveUrl, token: effectiveToken });
+    installStableCopy(root);
+    registerService();
+    console.log(
+      `\n✓ All set! This computer now ${cfg.doing} in the background —\n` +
+        "  whenever it's on, even after a restart. You can close this window.\n\n" +
+        `  Logs:      ${LOG_FILE}\n` +
+        `  Turn off:  npx --yes ${cfg.pkg} uninstall\n`,
+    );
+    const extra = cfg.afterInstall?.();
+    if (extra) console.log(extra);
+  }
+
+  // Removes THIS worker, not the whole ~/.goosetools directory: the Overlay
+  // Factory keeps its puzzle library, learned looks and used-card record in
+  // ~/.goosetools/overlay, and nothing else has a copy of those. The shared
+  // token file stays too — the other workers are still using it.
+  function uninstall() {
+    if (process.platform === "darwin") macUninstall();
+    else if (process.platform === "win32") winUninstall();
+    rmSync(APP_PREFIX, { recursive: true, force: true });
+    rmSync(LOG_FILE, { force: true });
+    rmSync(ERR_FILE, { force: true });
+    console.log(`✓ ${cfg.name} removed. (Your other workers and connection are untouched.)`);
+  }
+
+  // The daemon runs the COPY under ~/.goosetools/<appDir>, not wherever you ran
+  // this from — so new code only reaches it by reinstalling that copy.
+  // Re-registering the service also restarts it, which is what actually loads
+  // the new code (Node reads every module once, at startup).
+  function update({ root }) {
+    const saved = readEnvFile();
+    if (!saved.WORKER_TOKEN) {
+      console.error(`No saved worker token — this computer hasn't been connected yet.\n${connectHint}`);
+      process.exit(1);
+    }
+    const before = installedVersion();
+    installStableCopy(root);
+    registerService();
+    const after = installedVersion();
+    console.log(
+      after && before && after !== before
+        ? `\n✓ Updated ${before} → ${after} and restarted. Nothing else to do.\n`
+        : `\n✓ ${cfg.name} reinstalled (version ${after ?? "unknown"}) and restarted.\n`,
+    );
+  }
+
+  function status() {
+    const ok = (b) => (b ? "✓" : "✗");
+    const env = readEnvFile();
+    const installed = installedVersion();
+    const latest = latestVersion();
+    const pid = servicePid();
+    const url = env.GOOSETOOLS_URL ?? DEFAULT_URL;
+
+    console.log(`\nGoose Tools ${cfg.name.toLowerCase()} — status\n`);
+    console.log(`  ${ok(installed)} Installed        ${installed ?? "not installed"}`);
+    const cmp = installed && latest ? compareVersions(installed, latest) : 0;
+    const stale = cmp < 0;
+    if (latest) {
+      // Ahead of npm means a local dev install — say so rather than telling
+      // the user to "update" to something older than what they're running.
+      const note = stale ? "  ← update available" : cmp > 0 ? "  (you're ahead — local dev build)" : "";
+      console.log(`  ${ok(!stale)} Latest on npm    ${latest}${note}`);
+    } else {
+      console.log("  · Latest on npm    couldn't check (offline?)");
+    }
+    console.log(`  ${ok(pid)} Running          ${pid ? `yes (pid ${pid})` : "no"}`);
+    console.log(
+      `  ${ok(env.WORKER_TOKEN)} Token saved      ${env.WORKER_TOKEN ? "yes (shared)" : "no — run install --token gt_…"}`,
+    );
+    for (const line of cfg.statusLines?.() ?? []) console.log(line);
+    console.log(`  · Server           ${url}`);
+    console.log(`  · Logs             ${LOG_FILE}`);
+
+    const errors = tail(ERR_FILE, 15);
+    if (errors) {
+      console.log(`\nErrors (last written ${lastWritten(ERR_FILE)}):\n${errors.replace(/^/gm, "  ")}`);
+    }
+    const log = tail(LOG_FILE, 15);
+    if (log) {
+      console.log(`\nActivity (last written ${lastWritten(LOG_FILE)}):\n${log.replace(/^/gm, "  ")}`);
+    }
+
+    if (stale) {
+      console.log(`\nTo update:  npx --yes ${cfg.pkg}@latest update\n`);
+    } else if (!pid && installed) {
+      console.log(`\nNot running. Restart it with:  npx --yes ${cfg.pkg}@latest update\n`);
+    } else {
+      console.log("");
+    }
+  }
+
+  return { install, uninstall, update, status };
+}
+
+// A checkout (development) rather than an npm install. Inside the goosetools
+// repo the worker's folder has no .git of its own, so look for the sync
+// script next to it — that file is never published.
+function isCheckout(root) {
+  return existsSync(join(root, ".git")) || existsSync(join(root, "..", "sync-shared.mjs"));
+}

package/worker/service.js

@@ -1,395 +1,40 @@
-// Background-service install/uninstall for the Goose Tools worker.
-// `install` makes the worker persistent: token saved to ~/.goosetools/env,
-// a stable copy of this package installed under ~/.goosetools/app, and a
-// login service registered (launchd LaunchAgent on macOS, a logon Scheduled
-// Task on Windows) so the worker runs whenever the computer is on — no
-// terminal window needed.
-//
-// `update` re-runs that install against the newest code, reusing the saved
-// token; `status` reports what's actually running, for debugging.
+// Background service for the carousel worker. The install/update/status logic
+// is shared (worker/service-core.js, synced from workers/shared/); this file is
+// only what's specific to carousels: the optional ffmpeg for video slides.
+// Labels and paths must never change — see service-core.js. (This was the
+// first worker, which is why its names are the generic "worker"/"app".)
 
-import { execSync } from "node:child_process";
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
 import { FFMPEG_INSTALL_CMD } from "../src/video.js";
+import { createService, quietSh } from "./service-core.js";
 
-export const GOOSE_DIR = join(homedir(), ".goosetools");
-const ENV_FILE = join(GOOSE_DIR, "env");
-const APP_PREFIX = join(GOOSE_DIR, "app");
-const INSTALLED_CLI = join(APP_PREFIX, "node_modules", "goosetools-worker", "worker", "cli.js");
-
-const MAC_LABEL = "com.goosetools.worker";
-const MAC_PLIST = join(homedir(), "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
-const WIN_TASK = "GooseTools Worker";
-const WIN_VBS = join(GOOSE_DIR, "run-worker.vbs");
-
-function sh(cmd, opts = {}) {
-  return execSync(cmd, { stdio: ["ignore", "pipe", "pipe"], ...opts })
-    .toString()
-    .trim();
-}
-
-function quietSh(cmd) {
-  try {
-    sh(cmd);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Sync probe — the CLI's install/status paths are synchronous, and this is
-// only ever two cheap `-version` calls.
+// Only ever two cheap `-version` calls.
 function hasFfmpeg() {
   return quietSh("ffmpeg -version") && quietSh("ffprobe -version");
 }
 
-function npmGlobalBin() {
-  try {
-    const prefix = sh("npm prefix -g", { shell: true });
-    return process.platform === "win32" ? prefix : join(prefix, "bin");
-  } catch {
-    return "";
-  }
-}
-
-function servicePath() {
-  // Everything the daemon needs to find: node itself, the npm-global bin
-  // (where `claude` lives), plus the usual suspects.
-  const parts = [
-    dirname(process.execPath),
-    npmGlobalBin(),
-    ...(process.platform === "win32"
-      ? [process.env.PATH ?? ""]
-      : [
-          "/opt/homebrew/bin",
-          "/usr/local/bin",
-          `${process.env.HOME ?? ""}/.local/bin`,
-          "/usr/bin",
-          "/bin",
-          "/usr/sbin",
-          "/sbin",
-        ]),
-  ].filter(Boolean);
-  return [...new Set(parts)].join(process.platform === "win32" ? ";" : ":");
-}
-
-function writeEnvFile({ url, token }) {
-  mkdirSync(GOOSE_DIR, { recursive: true });
-  writeFileSync(ENV_FILE, `GOOSETOOLS_URL=${url}\nWORKER_TOKEN=${token}\n`);
-  chmodSync(ENV_FILE, 0o600);
-}
-
-function installStableCopy(root) {
-  console.log("Setting up the background copy (this can take a minute)…");
-  mkdirSync(APP_PREFIX, { recursive: true });
-  // From a git checkout (development), install the checkout itself;
-  // normal npx users get the published package.
-  const source = existsSync(join(root, ".git")) ? `"${root}"` : "goosetools-worker@latest";
-  execSync(`npm install --no-fund --no-audit --loglevel=error --prefix "${APP_PREFIX}" ${source}`, {
-    stdio: ["ignore", "inherit", "inherit"],
-    shell: true,
-  });
-  if (!existsSync(INSTALLED_CLI)) {
-    throw new Error("background copy did not install where expected");
-  }
-}
-
-// ── macOS (launchd) ──────────────────────────────────────────────────────────
-
-function macPlist() {
-  const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>${MAC_LABEL}</string>
-    <key>ProgramArguments</key>
-    <array>
-        <string>${esc(process.execPath)}</string>
-        <string>${esc(INSTALLED_CLI)}</string>
-        <string>run</string>
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <true/>
-    <key>ThrottleInterval</key>
-    <integer>30</integer>
-    <key>StandardOutPath</key>
-    <string>${esc(join(GOOSE_DIR, "worker.log"))}</string>
-    <key>StandardErrorPath</key>
-    <string>${esc(join(GOOSE_DIR, "worker.err.log"))}</string>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>${esc(servicePath())}</string>
-    </dict>
-</dict>
-</plist>
-`;
-}
-
-function macInstall() {
-  mkdirSync(dirname(MAC_PLIST), { recursive: true });
-  writeFileSync(MAC_PLIST, macPlist());
-  const uid = process.getuid();
-  // Re-registering: tear down any previous copy first, then bootstrap.
-  quietSh(`launchctl bootout gui/${uid}/${MAC_LABEL}`);
-  if (!quietSh(`launchctl bootstrap gui/${uid} "${MAC_PLIST}"`)) {
-    // Older macOS fallback.
-    quietSh(`launchctl unload "${MAC_PLIST}"`);
-    execSync(`launchctl load -w "${MAC_PLIST}"`, { stdio: "ignore" });
-  }
-}
-
-function macUninstall() {
-  quietSh(`launchctl bootout gui/${process.getuid()}/${MAC_LABEL}`);
-  quietSh(`launchctl unload "${MAC_PLIST}"`);
-  rmSync(MAC_PLIST, { force: true });
-}
-
-// ── Windows (Scheduled Task at logon, hidden window) ─────────────────────────
-
-function winInstall() {
-  // wscript launches the worker with no console window.
-  const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${INSTALLED_CLI}"" run", 0, False\r\n`;
-  writeFileSync(WIN_VBS, vbs);
-  quietSh(`schtasks /End /TN "${WIN_TASK}"`);
-  quietSh(`schtasks /Delete /F /TN "${WIN_TASK}"`);
-  execSync(`schtasks /Create /F /SC ONLOGON /TN "${WIN_TASK}" /TR "wscript.exe \\"${WIN_VBS}\\""`, {
-    stdio: "ignore",
-    shell: true,
-  });
-  execSync(`schtasks /Run /TN "${WIN_TASK}"`, { stdio: "ignore", shell: true });
-}
-
-function winUninstall() {
-  quietSh(`schtasks /End /TN "${WIN_TASK}"`);
-  quietSh(`schtasks /Delete /F /TN "${WIN_TASK}"`);
-  rmSync(WIN_VBS, { force: true });
-}
-
-// ── Public commands ──────────────────────────────────────────────────────────
-
-export function install({ url, token, root }) {
-  if (!token) {
-    console.error("Missing worker token. Run: goosetools-worker install --url " + url + " --token gt_…");
-    process.exit(1);
-  }
-  writeEnvFile({ url, token });
-  installStableCopy(root);
-  if (process.platform === "darwin") macInstall();
-  else if (process.platform === "win32") winInstall();
-  else {
-    console.error(
-      "Automatic background setup isn't available on this OS yet.\n" +
-        "Run the worker directly instead:  goosetools-worker run",
-    );
-    process.exit(1);
-  }
-  console.log(
-    "\n✓ All set! Your computer now connects to Goose Tools by itself —\n" +
-      "  in the background, whenever it's on, even after a restart.\n" +
-      "  You can close this window.\n\n" +
-      `  Logs:      ${join(GOOSE_DIR, "worker.log")}\n` +
-      "  Turn off:  npx --yes goosetools-worker uninstall\n",
-  );
+export const { install, uninstall, update, status } = createService({
+  pkg: "goosetools-worker",
+  name: "Carousel worker",
+  appDir: "app",
+  macLabel: "com.goosetools.worker",
+  winTask: "GooseTools Worker",
+  winVbs: "run-worker.vbs",
+  logName: "worker",
+  dashboard: "/dashboard/carousel",
+  doing: "makes your carousels",
   // Optional, and only worth a mention once the required setup has succeeded:
   // photo carousels are already fully working at this point.
-  if (!hasFfmpeg()) {
-    console.log(
-      "  Optional — want video slides?\n" +
+  afterInstall: () =>
+    hasFfmpeg()
+      ? undefined
+      : "  Optional — want video slides?\n" +
         "  Carousels made from photos work right now. To also put video clips\n" +
         "  in a carousel, install ffmpeg (one time, a couple of minutes):\n\n" +
         `      ${FFMPEG_INSTALL_CMD}\n`,
-    );
-  }
-}
-
-// Removes THIS worker, not the whole ~/.goosetools directory. It used to take
-// the directory, which was harmless while everything in there was either this
-// worker's or re-derivable from the server — and stopped being harmless when
-// the Overlay Factory started keeping its puzzle library, learned looks and
-// used-card record in ~/.goosetools/overlay. Nothing else has a copy of those,
-// and `npx goosetools uninstall` runs this. The shared token file stays: the
-// other workers are still using it.
-export function uninstall() {
-  if (process.platform === "darwin") macUninstall();
-  else if (process.platform === "win32") winUninstall();
-  rmSync(APP_PREFIX, { recursive: true, force: true });
-  rmSync(join(GOOSE_DIR, "worker.log"), { force: true });
-  rmSync(join(GOOSE_DIR, "worker.err.log"), { force: true });
-  console.log("✓ Carousel worker removed. This computer no longer makes carousels.");
-}
-
-// ── update ───────────────────────────────────────────────────────────────────
-// The daemon runs the COPY under ~/.goosetools/app, not wherever you ran this
-// from — so new code only reaches it by reinstalling that copy. Re-registering
-// the service also restarts it, which is what actually loads the new code
-// (Node reads every module once, at startup).
-export function update({ root }) {
-  const saved = readEnvFile();
-  if (!saved.WORKER_TOKEN) {
-    console.error(
-      "No saved worker token — this computer hasn't been connected yet.\n" +
-        "Get a token at https://goosetools.com/dashboard/carousel and run:\n" +
-        "  npx --yes goosetools-worker@latest install --token gt_…",
-    );
-    process.exit(1);
-  }
-  const before = installedVersion();
-  installStableCopy(root);
-  if (process.platform === "darwin") macInstall();
-  else if (process.platform === "win32") winInstall();
-  else {
-    console.error("Automatic background setup isn't available on this OS yet.");
-    process.exit(1);
-  }
-  const after = installedVersion();
-  console.log(
-    after && before && after !== before
-      ? `\n✓ Updated ${before} → ${after} and restarted. Nothing else to do.\n`
-      : `\n✓ Worker reinstalled (version ${after ?? "unknown"}) and restarted.\n`,
-  );
-}
-
-// ── status ───────────────────────────────────────────────────────────────────
-function readEnvFile() {
-  if (!existsSync(ENV_FILE)) return {};
-  return Object.fromEntries(
-    readFileSync(ENV_FILE, "utf8")
-      .split("\n")
-      .filter((l) => l.includes("=") && !l.trim().startsWith("#"))
-      .map((l) => [l.slice(0, l.indexOf("=")).trim(), l.slice(l.indexOf("=") + 1).trim()]),
-  );
-}
-
-function installedVersion() {
-  try {
-    const pkg = join(APP_PREFIX, "node_modules", "goosetools-worker", "package.json");
-    return JSON.parse(readFileSync(pkg, "utf8")).version ?? null;
-  } catch {
-    return null;
-  }
-}
-
-function latestVersion() {
-  try {
-    return sh("npm view goosetools-worker version", { shell: true, timeout: 15000 });
-  } catch {
-    return null; // offline, or npm unreachable — not an error worth failing on
-  }
-}
-
-// -1 / 0 / 1, comparing x.y.z numerically. Anything unparseable sorts equal so
-// an odd version string never nags the user to "update" in a loop.
-function compareVersions(a, b) {
-  const parts = (v) => String(v).split(".").map((n) => Number.parseInt(n, 10) || 0);
-  const [pa, pb] = [parts(a), parts(b)];
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) < (pb[i] ?? 0) ? -1 : 1;
-  }
-  return 0;
-}
-
-// launchctl prints "<pid>\t<last exit>\t<label>"; a "-" pid means registered
-// but not currently running.
-function servicePid() {
-  try {
-    if (process.platform === "darwin") {
-      const line = sh(`launchctl list | grep ${MAC_LABEL}`, { shell: true });
-      const pid = line.split(/\s+/)[0];
-      return pid === "-" ? null : pid;
-    }
-    const out = sh(`schtasks /Query /TN "${WIN_TASK}" /FO LIST`, { shell: true });
-    return /Running/i.test(out) ? "running" : null;
-  } catch {
-    return null;
-  }
-}
-
-function tail(file, n) {
-  try {
-    return readFileSync(file, "utf8").trimEnd().split("\n").slice(-n).join("\n");
-  } catch {
-    return "";
-  }
-}
-
-// How long ago a log was last written. Without this, days-old errors read as
-// a live outage — the single most misleading thing in a log tail.
-function lastWritten(file) {
-  try {
-    const ms = Date.now() - statSync(file).mtimeMs;
-    const mins = Math.round(ms / 60000);
-    if (mins < 1) return "just now";
-    if (mins < 60) return `${mins} min ago`;
-    const hours = Math.round(mins / 60);
-    if (hours < 24) return `${hours} hr ago`;
-    return `${Math.round(hours / 24)} days ago`;
-  } catch {
-    return "unknown";
-  }
-}
-
-export function status() {
-  const ok = (b) => (b ? "✓" : "✗");
-  const env = readEnvFile();
-  const installed = installedVersion();
-  const latest = latestVersion();
-  const pid = servicePid();
-  const url = env.GOOSETOOLS_URL ?? "https://goosetools.com";
-
-  console.log("\nGoose Tools worker — status\n");
-  console.log(`  ${ok(installed)} Installed        ${installed ?? "not installed"}`);
-  // Ahead of npm means a local dev install — say so rather than telling the
-  // user to "update" to something older than what they're running.
-  const cmp = installed && latest ? compareVersions(installed, latest) : 0;
-  const stale = cmp < 0;
-  if (latest) {
-    const note = stale ? "  ← update available" : cmp > 0 ? "  (you're ahead — local dev build)" : "";
-    console.log(`  ${ok(!stale)} Latest on npm    ${latest}${note}`);
-  } else {
-    console.log("  · Latest on npm    couldn't check (offline?)");
-  }
-  console.log(`  ${ok(pid)} Running          ${pid ? `yes (pid ${pid})` : "no"}`);
-  console.log(`  ${ok(env.WORKER_TOKEN)} Token saved      ${env.WORKER_TOKEN ? "yes" : "no — run install --token gt_…"}`);
   // Not an "✗": a worker without ffmpeg is healthy, it just can't do video.
-  console.log(
+  statusLines: () => [
     `  ${hasFfmpeg() ? "✓" : "·"} Video slides     ${
       hasFfmpeg() ? "yes (ffmpeg found)" : `photos only — for video: ${FFMPEG_INSTALL_CMD}`
     }`,
-  );
-  console.log(`  · Server           ${url}`);
-  console.log(`  · Logs             ${join(GOOSE_DIR, "worker.log")}`);
-
-  const errFile = join(GOOSE_DIR, "worker.err.log");
-  const errors = tail(errFile, 15);
-  if (errors) {
-    console.log(`\nErrors (last written ${lastWritten(errFile)}):\n${errors.replace(/^/gm, "  ")}`);
-  }
-  const logFile = join(GOOSE_DIR, "worker.log");
-  const log = tail(logFile, 15);
-  if (log) {
-    console.log(`\nActivity (last written ${lastWritten(logFile)}):\n${log.replace(/^/gm, "  ")}`);
-  }
-
-  if (stale) {
-    console.log("\nTo update:  npx --yes goosetools-worker@latest update\n");
-  } else if (!pid && installed) {
-    console.log("\nNot running. Restart it with:  npx --yes goosetools-worker@latest update\n");
-  } else {
-    console.log("");
-  }
-}
+  ],
+});