@forwardimpact/basecamp 0.1.0 → 0.2.0

package/README.md

@@ -186,7 +186,7 @@ fit-basecamp --status            Show knowledge bases and task status
 fit-basecamp --help              Show this help
 ```
 
-When running from source, use `node scheduler.js` or `npx fit-basecamp` instead
+When running from source, use `node basecamp.js` or `npx fit-basecamp` instead
 of `fit-basecamp`.
 
 ## How It Works

package/{scheduler.js → basecamp.js}

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 
-// Basecamp Scheduler — Runs scheduled tasks across multiple knowledge bases.
+// Basecamp — CLI and scheduler for personal knowledge bases.
 //
 // Usage:
-//   node scheduler.js                     Run due tasks once and exit
-//   node scheduler.js --daemon            Run continuously (poll every 60s)
-//   node scheduler.js --run <task>        Run a specific task immediately
-//   node scheduler.js --init <path>       Initialize a new knowledge base
-//   node scheduler.js --install-launchd   Install macOS LaunchAgent
-//   node scheduler.js --uninstall-launchd Remove macOS LaunchAgent
-//   node scheduler.js --validate          Validate agents and skills exist
-//   node scheduler.js --status            Show task status
-//   node scheduler.js --help              Show this help
+//   node basecamp.js                     Run due tasks once and exit
+//   node basecamp.js --daemon            Run continuously (poll every 60s)
+//   node basecamp.js --run <task>        Run a specific task immediately
+//   node basecamp.js --init <path>       Initialize a new knowledge base
+//   node basecamp.js --install-launchd   Install macOS LaunchAgent
+//   node basecamp.js --uninstall-launchd Remove macOS LaunchAgent
+//   node basecamp.js --validate          Validate agents and skills exist
+//   node basecamp.js --status            Show task status
+//   node basecamp.js --help              Show this help
 
 import {
   readFileSync,
@@ -19,11 +19,15 @@ import {
   existsSync,
   mkdirSync,
   readdirSync,
+  unlinkSync,
+  chmodSync,
 } from "node:fs";
 import { execSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { join, dirname, resolve } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { createServer } from "node:net";
 
 const HOME = homedir();
 const BASECAMP_HOME = join(HOME, ".fit", "basecamp");
@@ -35,11 +39,14 @@ const PLIST_PATH = join(HOME, "Library", "LaunchAgents", `${PLIST_NAME}.plist`);
 const __dirname =
   import.meta.dirname || dirname(fileURLToPath(import.meta.url));
 const KB_TEMPLATE_DIR = join(__dirname, "template");
+const SOCKET_PATH = join(BASECAMP_HOME, "basecamp.sock");
 const IS_COMPILED =
   typeof Deno !== "undefined" &&
   Deno.execPath &&
   !Deno.execPath().endsWith("deno");
 
+let daemonStartedAt = null;
+
 // --- Helpers ----------------------------------------------------------------
 
 function ensureDir(dir) {
@@ -152,6 +159,7 @@ function floorToMinute(d) {
 
 function shouldRun(task, taskState, now) {
   if (task.enabled === false) return false;
+  if (taskState.status === "running") return false;
   const { schedule } = task;
   if (!schedule) return false;
   const lastRun = taskState.lastRunAt ? new Date(taskState.lastRunAt) : null;
@@ -197,63 +205,254 @@ function runTask(taskName, task, _config, state) {
   ts.startedAt = new Date().toISOString();
   saveState(state);
 
-  try {
-    const args = ["--print"];
-    if (task.agent) args.push("--agent", task.agent);
-    args.push("-p", prompt);
-
-    const result = execSync(
-      `${claude} ${args.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ")}`,
-      {
-        cwd: kbPath,
-        encoding: "utf8",
-        timeout: 30 * 60_000,
-        stdio: ["pipe", "pipe", "pipe"],
-      },
-    );
+  const spawnArgs = ["--print"];
+  if (task.agent) spawnArgs.push("--agent", task.agent);
+  spawnArgs.push("-p", prompt);
 
-    log(`Task ${taskName} completed. Output: ${result.slice(0, 200)}...`);
-    Object.assign(ts, {
-      status: "finished",
-      lastRunAt: new Date().toISOString(),
-      lastError: null,
-      runCount: (ts.runCount || 0) + 1,
+  return new Promise((resolve) => {
+    const child = spawn(claude, spawnArgs, {
+      cwd: kbPath,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 30 * 60_000,
     });
-  } catch (err) {
-    const errMsg = err.stderr || err.stdout || err.message || String(err);
-    log(`Task ${taskName} failed: ${errMsg.slice(0, 300)}`);
-    Object.assign(ts, {
-      status: "failed",
-      lastRunAt: new Date().toISOString(),
-      lastError: errMsg.slice(0, 500),
+
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => (stdout += d));
+    child.stderr.on("data", (d) => (stderr += d));
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        log(`Task ${taskName} completed. Output: ${stdout.slice(0, 200)}...`);
+        Object.assign(ts, {
+          status: "finished",
+          startedAt: null,
+          lastRunAt: new Date().toISOString(),
+          lastError: null,
+          runCount: (ts.runCount || 0) + 1,
+        });
+      } else {
+        const errMsg = stderr || stdout || `Exit code ${code}`;
+        log(`Task ${taskName} failed: ${errMsg.slice(0, 300)}`);
+        Object.assign(ts, {
+          status: "failed",
+          startedAt: null,
+          lastRunAt: new Date().toISOString(),
+          lastError: errMsg.slice(0, 500),
+        });
+      }
+      saveState(state);
+      resolve();
     });
-  }
-  saveState(state);
+
+    child.on("error", (err) => {
+      log(`Task ${taskName} failed: ${err.message}`);
+      Object.assign(ts, {
+        status: "failed",
+        startedAt: null,
+        lastRunAt: new Date().toISOString(),
+        lastError: err.message.slice(0, 500),
+      });
+      saveState(state);
+      resolve();
+    });
+  });
 }
 
-function runDueTasks() {
+async function runDueTasks() {
   const config = loadConfig(),
     state = loadState(),
     now = new Date();
   let ranAny = false;
   for (const [name, task] of Object.entries(config.tasks)) {
     if (shouldRun(task, state.tasks[name] || {}, now)) {
-      runTask(name, task, config, state);
+      await runTask(name, task, config, state);
       ranAny = true;
     }
   }
   if (!ranAny) log("No tasks due.");
 }
 
+// --- Next-run computation ---------------------------------------------------
+
+/** @param {object} task @param {object} taskState @param {Date} now */
+function computeNextRunAt(task, taskState, now) {
+  if (task.enabled === false) return null;
+  const { schedule } = task;
+  if (!schedule) return null;
+
+  if (schedule.type === "interval") {
+    const ms = (schedule.minutes || 5) * 60_000;
+    const lastRun = taskState.lastRunAt ? new Date(taskState.lastRunAt) : null;
+    if (!lastRun) return now.toISOString();
+    return new Date(lastRun.getTime() + ms).toISOString();
+  }
+
+  if (schedule.type === "cron") {
+    const limit = 24 * 60;
+    const start = new Date(floorToMinute(now) + 60_000);
+    for (let i = 0; i < limit; i++) {
+      const candidate = new Date(start.getTime() + i * 60_000);
+      if (cronMatches(schedule.expression, candidate)) {
+        return candidate.toISOString();
+      }
+    }
+    return null;
+  }
+
+  if (schedule.type === "once") {
+    if (taskState.lastRunAt) return null;
+    return schedule.runAt;
+  }
+
+  return null;
+}
+
+// --- Socket server ----------------------------------------------------------
+
+/** @param {import('node:net').Socket} socket @param {object} data */
+function send(socket, data) {
+  try {
+    socket.write(JSON.stringify(data) + "\n");
+  } catch {}
+}
+
+function handleStatusRequest(socket) {
+  const config = loadConfig();
+  const state = loadState();
+  const now = new Date();
+  const tasks = {};
+
+  for (const [name, task] of Object.entries(config.tasks)) {
+    const ts = state.tasks[name] || {};
+    tasks[name] = {
+      enabled: task.enabled !== false,
+      status: ts.status || "never-run",
+      lastRunAt: ts.lastRunAt || null,
+      nextRunAt: computeNextRunAt(task, ts, now),
+      runCount: ts.runCount || 0,
+      lastError: ts.lastError || null,
+    };
+    if (ts.startedAt) tasks[name].startedAt = ts.startedAt;
+  }
+
+  send(socket, {
+    type: "status",
+    uptime: daemonStartedAt
+      ? Math.floor((Date.now() - daemonStartedAt) / 1000)
+      : 0,
+    tasks,
+  });
+}
+
+function handleRestartRequest(socket) {
+  send(socket, { type: "ack", command: "restart" });
+  const uid = execSync("id -u", { encoding: "utf8" }).trim();
+  setTimeout(() => {
+    try {
+      execSync(`launchctl kickstart -k gui/${uid}/${PLIST_NAME}`);
+    } catch {
+      process.exit(0);
+    }
+  }, 100);
+}
+
+function handleRunRequest(socket, taskName) {
+  if (!taskName) {
+    send(socket, { type: "error", message: "Missing task name" });
+    return;
+  }
+  const config = loadConfig();
+  const task = config.tasks[taskName];
+  if (!task) {
+    send(socket, { type: "error", message: `Task not found: ${taskName}` });
+    return;
+  }
+  send(socket, { type: "ack", command: "run", task: taskName });
+  const state = loadState();
+  runTask(taskName, task, config, state).catch((err) => {
+    console.error(`[socket] runTask error for ${taskName}:`, err.message);
+  });
+}
+
+function handleMessage(socket, line) {
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch {
+    send(socket, { type: "error", message: "Invalid JSON" });
+    return;
+  }
+
+  const handlers = {
+    status: () => handleStatusRequest(socket),
+    restart: () => handleRestartRequest(socket),
+    run: () => handleRunRequest(socket, request.task),
+  };
+
+  const handler = handlers[request.type];
+  if (handler) {
+    handler();
+  } else {
+    send(socket, {
+      type: "error",
+      message: `Unknown request type: ${request.type}`,
+    });
+  }
+}
+
+function startSocketServer() {
+  try {
+    unlinkSync(SOCKET_PATH);
+  } catch {}
+
+  const server = createServer((socket) => {
+    let buffer = "";
+    socket.on("data", (data) => {
+      buffer += data.toString();
+      let idx;
+      while ((idx = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, idx).trim();
+        buffer = buffer.slice(idx + 1);
+        if (line) handleMessage(socket, line);
+      }
+    });
+    socket.on("error", () => {});
+  });
+
+  server.listen(SOCKET_PATH, () => {
+    chmodSync(SOCKET_PATH, 0o600);
+    log(`Socket server listening on ${SOCKET_PATH}`);
+  });
+
+  server.on("error", (err) => {
+    log(`Socket server error: ${err.message}`);
+  });
+
+  const cleanup = () => {
+    server.close();
+    try {
+      unlinkSync(SOCKET_PATH);
+    } catch {}
+    process.exit(0);
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+
+  return server;
+}
+
 // --- Daemon -----------------------------------------------------------------
 
 function daemon() {
+  daemonStartedAt = Date.now();
   log("Scheduler daemon started. Polling every 60 seconds.");
   log(`Config: ${CONFIG_PATH}  State: ${STATE_PATH}`);
+  startSocketServer();
   runDueTasks();
-  setInterval(() => {
+  setInterval(async () => {
     try {
-      runDueTasks();
+      await runDueTasks();
     } catch (err) {
       log(`Error: ${err.message}`);
     }
@@ -307,7 +506,7 @@ function installLaunchd() {
   const isCompiled = IS_COMPILED || !execPath.includes("node");
   const progArgs = isCompiled
     ? `    <string>${execPath}</string>\n    <string>--daemon</string>`
-    : `    <string>${execPath}</string>\n    <string>${join(__dirname, "scheduler.js")}</string>\n    <string>--daemon</string>`;
+    : `    <string>${execPath}</string>\n    <string>${join(__dirname, "basecamp.js")}</string>\n    <string>--daemon</string>`;
 
   const plist = `<?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">
@@ -526,14 +725,14 @@ const commands = {
   "--status": showStatus,
   "--init": () => {
     if (!args[1]) {
-      console.error("Usage: node scheduler.js --init <path>");
+      console.error("Usage: node basecamp.js --init <path>");
       process.exit(1);
     }
     initKB(args[1]);
   },
-  "--run": () => {
+  "--run": async () => {
     if (!args[1]) {
-      console.error("Usage: node scheduler.js --run <task-name>");
+      console.error("Usage: node basecamp.js --run <task-name>");
       process.exit(1);
     }
     const config = loadConfig(),
@@ -545,8 +744,8 @@ const commands = {
       );
       process.exit(1);
     }
-    runTask(args[1], task, config, state);
+    await runTask(args[1], task, config, state);
   },
 };
 
-(commands[command] || runDueTasks)();
+await (commands[command] || runDueTasks)();

package/build.js

@@ -1,17 +1,12 @@
 #!/usr/bin/env -S deno run --allow-all
 
-// Build script for Basecamp.
+// Build script for Basecamp (arm64 macOS).
 //
 // Usage:
-//   deno run --allow-all build.js             Build standalone executable (current arch)
-//   deno run --allow-all build.js --pkg       Build executable + macOS .pkg installer
-//   deno run --allow-all build.js --all       Build for both arm64 and x86_64 + .pkg
-//
-// Or via deno tasks:
-//   deno task build
-//   deno task build:pkg
+//   deno run --allow-all build.js         Build standalone executable
+//   deno run --allow-all build.js --pkg   Build executable + macOS .pkg installer
 
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { execSync } from "node:child_process";
 
@@ -19,7 +14,11 @@ const __dirname =
   import.meta.dirname || dirname(new URL(import.meta.url).pathname);
 const DIST_DIR = join(__dirname, "dist");
 const APP_NAME = "fit-basecamp";
-const VERSION = "1.0.0";
+const STATUS_MENU_NAME = "BasecampStatus";
+const STATUS_MENU_DIR = join(__dirname, "StatusMenu");
+const VERSION = JSON.parse(
+  readFileSync(join(__dirname, "package.json"), "utf8"),
+).version;
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -34,32 +33,23 @@ function run(cmd, opts = {}) {
   return execSync(cmd, { encoding: "utf8", stdio: "inherit", ...opts });
 }
 
-function runCapture(cmd) {
-  return execSync(cmd, {
-    encoding: "utf8",
-    stdio: ["pipe", "pipe", "pipe"],
-  }).trim();
-}
-
 // ---------------------------------------------------------------------------
 // Compile standalone binary
 // ---------------------------------------------------------------------------
 
-function compile(target = null) {
-  const arch = target || detectArch();
-  const outputName = target ? `${APP_NAME}-${arch}` : APP_NAME;
-  const outputPath = join(DIST_DIR, outputName);
+function compile() {
+  const outputPath = join(DIST_DIR, APP_NAME);
 
-  console.log(`\nCompiling ${APP_NAME} for ${arch}...`);
+  console.log(`\nCompiling ${APP_NAME}...`);
   ensureDir(DIST_DIR);
 
   const cmd = [
     "deno compile",
     "--allow-all",
-    `--target ${arch}`,
+    "--no-check",
     `--output "${outputPath}"`,
     "--include template/",
-    "scheduler.js",
+    "basecamp.js",
   ].join(" ");
 
   run(cmd, { cwd: __dirname });
@@ -68,26 +58,43 @@ function compile(target = null) {
   return outputPath;
 }
 
-function detectArch() {
-  const arch = runCapture("uname -m");
-  if (arch === "arm64") return "aarch64-apple-darwin";
-  return "x86_64-apple-darwin";
+// ---------------------------------------------------------------------------
+// Compile Swift status menu binary
+// ---------------------------------------------------------------------------
+
+function compileStatusMenu() {
+  console.log(`\nCompiling ${STATUS_MENU_NAME}...`);
+  ensureDir(DIST_DIR);
+
+  const buildDir = join(STATUS_MENU_DIR, ".build");
+  rmSync(buildDir, { recursive: true, force: true });
+
+  run("swift build -c release", { cwd: STATUS_MENU_DIR });
+
+  const binary = join(buildDir, "release", STATUS_MENU_NAME);
+  const outputPath = join(DIST_DIR, STATUS_MENU_NAME);
+  run(`cp "${binary}" "${outputPath}"`);
+
+  rmSync(buildDir, { recursive: true, force: true });
+
+  console.log(`  -> ${outputPath}`);
+  return outputPath;
 }
 
 // ---------------------------------------------------------------------------
 // Build macOS installer package (.pkg)
 // ---------------------------------------------------------------------------
 
-function buildPKG(binaryPath, arch) {
-  const archShort = arch.includes("aarch64") ? "arm64" : "x86_64";
-  const pkgName = `${APP_NAME}-${VERSION}-${archShort}.pkg`;
+function buildPKG(statusMenuBinaryPath) {
+  const pkgName = `${APP_NAME}-${VERSION}.pkg`;
 
   console.log(`\nBuilding pkg: ${pkgName}...`);
 
   const buildPkg = join(__dirname, "scripts", "build-pkg.sh");
-  run(`"${buildPkg}" "${DIST_DIR}" "${APP_NAME}" "${VERSION}" "${arch}"`, {
-    cwd: __dirname,
-  });
+  run(
+    `"${buildPkg}" "${DIST_DIR}" "${APP_NAME}" "${VERSION}" "${statusMenuBinaryPath}"`,
+    { cwd: __dirname },
+  );
 
   console.log(`  -> ${join(DIST_DIR, pkgName)}`);
   return join(DIST_DIR, pkgName);
@@ -99,26 +106,17 @@ function buildPKG(binaryPath, arch) {
 
 const args = Deno?.args || process.argv.slice(2);
 const wantPKG = args.includes("--pkg");
-const wantAll = args.includes("--all");
 
 console.log(`Basecamp Build (v${VERSION})`);
 console.log("==========================");
 
-if (wantAll) {
-  // Build for both architectures
-  const targets = ["aarch64-apple-darwin", "x86_64-apple-darwin"];
-  for (const target of targets) {
-    const binary = compile(target);
-    buildPKG(binary, target);
-  }
-} else {
-  // Build for current architecture
-  const arch = detectArch();
-  const binary = compile(arch);
-
-  if (wantPKG) {
-    buildPKG(binary, arch);
-  }
+// Compile Deno binary first (before status menu exists in dist/),
+// so the status menu binary is not embedded in the Deno binary.
+compile();
+const statusMenuBinary = compileStatusMenu();
+
+if (wantPKG) {
+  buildPKG(statusMenuBinary);
 }
 
 console.log("\nBuild complete! Output in dist/");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/basecamp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Claude Code-native personal knowledge system with scheduled tasks",
   "license": "Apache-2.0",
   "repository": {
@@ -10,22 +10,22 @@
   },
   "homepage": "https://www.forwardimpact.team/basecamp",
   "type": "module",
-  "main": "scheduler.js",
+  "main": "basecamp.js",
   "bin": {
-    "fit-basecamp": "./scheduler.js"
+    "fit-basecamp": "./basecamp.js"
   },
   "scripts": {
-    "start": "node scheduler.js",
-    "status": "node scheduler.js --status",
+    "start": "node basecamp.js",
+    "status": "node basecamp.js --status",
     "build": "deno run --allow-all build.js",
     "build:pkg": "deno run --allow-all build.js --pkg",
     "build:all": "deno run --allow-all build.js --all",
     "install:basecamp": "./scripts/install.sh",
-    "scheduler:install": "node scheduler.js --install-launchd",
-    "scheduler:uninstall": "node scheduler.js --uninstall-launchd"
+    "scheduler:install": "node basecamp.js --install-launchd",
+    "scheduler:uninstall": "node basecamp.js --uninstall-launchd"
   },
   "files": [
-    "scheduler.js",
+    "basecamp.js",
     "build.js",
     "config/",
     "scripts/",

package/scripts/build-pkg.sh

@@ -1,23 +1,23 @@
 #!/bin/bash
 set -e
 
-# Build a macOS installer package (.pkg) for Basecamp.
+# Build a macOS installer package (.pkg) for Basecamp (arm64).
 #
 # Uses pkgbuild (component) + productbuild (distribution) to create a .pkg
 # that installs the binary to /usr/local/bin/ and runs a postinstall script
 # to set up the LaunchAgent, config, and default knowledge base.
 #
-# Usage: build-pkg.sh <dist_dir> <app_name> <version> <target>
-#   e.g.  build-pkg.sh dist basecamp 1.0.0 aarch64-apple-darwin
+# Usage: build-pkg.sh <dist_dir> <app_name> <version> <status_menu_binary>
+#   e.g.  build-pkg.sh dist fit-basecamp 1.0.0 dist/BasecampStatus
 
-DIST_DIR="${1:?Usage: build-pkg.sh <dist_dir> <app_name> <version> <target>}"
-APP_NAME="${2:?Usage: build-pkg.sh <dist_dir> <app_name> <version> <target>}"
-VERSION="${3:?Usage: build-pkg.sh <dist_dir> <app_name> <version> <target>}"
-TARGET="${4:?Usage: build-pkg.sh <dist_dir> <app_name> <version> <target>}"
+DIST_DIR="${1:?Usage: build-pkg.sh <dist_dir> <app_name> <version> <status_menu_binary>}"
+APP_NAME="${2:?Usage: build-pkg.sh <dist_dir> <app_name> <version> <status_menu_binary>}"
+VERSION="${3:?Usage: build-pkg.sh <dist_dir> <app_name> <version> <status_menu_binary>}"
+STATUS_MENU_BINARY="${4:?Usage: build-pkg.sh <dist_dir> <app_name> <version> <status_menu_binary>}"
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
-BINARY_PATH="$DIST_DIR/$APP_NAME-$TARGET"
+BINARY_PATH="$DIST_DIR/$APP_NAME"
 IDENTIFIER="com.fit-basecamp.scheduler"
 
 if [ ! -f "$BINARY_PATH" ]; then
@@ -26,18 +26,12 @@ if [ ! -f "$BINARY_PATH" ]; then
   exit 1
 fi
 
-# Determine short arch name
-case "$TARGET" in
-  *aarch64*) ARCH_SHORT="arm64" ;;
-  *)         ARCH_SHORT="x86_64" ;;
-esac
-
-PKG_NAME="$APP_NAME-$VERSION-$ARCH_SHORT.pkg"
+PKG_NAME="$APP_NAME-$VERSION.pkg"
 PKG_PATH="$DIST_DIR/$PKG_NAME"
-PAYLOAD_DIR="$DIST_DIR/pkg-payload-$ARCH_SHORT"
-SCRIPTS_DIR="$DIST_DIR/pkg-scripts-$ARCH_SHORT"
-RESOURCES_DIR="$DIST_DIR/pkg-resources-$ARCH_SHORT"
-COMPONENT_PKG="$DIST_DIR/pkg-component-$ARCH_SHORT.pkg"
+PAYLOAD_DIR="$DIST_DIR/pkg-payload"
+SCRIPTS_DIR="$DIST_DIR/pkg-scripts"
+RESOURCES_DIR="$DIST_DIR/pkg-resources"
+COMPONENT_PKG="$DIST_DIR/pkg-component.pkg"
 
 echo ""
 echo "Building pkg: $PKG_NAME..."
@@ -59,6 +53,10 @@ cp "$PROJECT_DIR/config/scheduler.json" "$PAYLOAD_DIR/usr/local/share/fit-baseca
 cp "$SCRIPT_DIR/uninstall.sh" "$PAYLOAD_DIR/usr/local/share/fit-basecamp/uninstall.sh"
 chmod +x "$PAYLOAD_DIR/usr/local/share/fit-basecamp/uninstall.sh"
 
+# Status menu binary
+cp "$STATUS_MENU_BINARY" "$PAYLOAD_DIR/usr/local/bin/BasecampStatus"
+chmod +x "$PAYLOAD_DIR/usr/local/bin/BasecampStatus"
+
 # --- Create scripts directory ------------------------------------------------
 
 mkdir -p "$SCRIPTS_DIR"
@@ -83,16 +81,16 @@ cp "$SCRIPT_DIR/pkg-resources/conclusion.html" "$RESOURCES_DIR/conclusion.html"
 
 # --- Create distribution.xml ------------------------------------------------
 
-DIST_XML="$DIST_DIR/distribution-$ARCH_SHORT.xml"
+DIST_XML="$DIST_DIR/distribution.xml"
 cat > "$DIST_XML" <<EOF
 <?xml version="1.0" encoding="utf-8"?>
 <installer-gui-script minSpecVersion="2">
     <title>Basecamp ${VERSION}</title>
     <welcome  file="welcome.html"    mime-type="text/html" />
     <conclusion file="conclusion.html" mime-type="text/html" />
-    <options customize="never" require-scripts="false" hostArchitectures="$ARCH_SHORT" />
+    <options customize="never" require-scripts="false" hostArchitectures="arm64" />
     <domains enable_localSystem="true" />
-    <pkg-ref id="$IDENTIFIER" version="$VERSION">pkg-component-$ARCH_SHORT.pkg</pkg-ref>
+    <pkg-ref id="$IDENTIFIER" version="$VERSION">pkg-component.pkg</pkg-ref>
     <choices-outline>
         <line choice="$IDENTIFIER" />
     </choices-outline>
@@ -114,4 +112,4 @@ productbuild \
 
 rm -rf "$PAYLOAD_DIR" "$SCRIPTS_DIR" "$RESOURCES_DIR" "$COMPONENT_PKG" "$DIST_XML"
 
-echo "  -> $PKG_PATH"
+echo "  -> $PKG_NAME"

package/scripts/compile.sh

@@ -1,26 +1,25 @@
 #!/bin/bash
 set -e
 
-# Compile Basecamp into a standalone Deno binary.
+# Compile Basecamp into a standalone Deno binary (arm64 macOS).
 #
-# Usage: compile.sh <dist_dir> <app_name> <target>
-#   e.g.  compile.sh dist basecamp aarch64-apple-darwin
+# Usage: compile.sh <dist_dir> <app_name>
+#   e.g.  compile.sh dist fit-basecamp
 
-DIST_DIR="${1:?Usage: compile.sh <dist_dir> <app_name> <target>}"
-APP_NAME="${2:?Usage: compile.sh <dist_dir> <app_name> <target>}"
-TARGET="${3:?Usage: compile.sh <dist_dir> <app_name> <target>}"
+DIST_DIR="${1:?Usage: compile.sh <dist_dir> <app_name>}"
+APP_NAME="${2:?Usage: compile.sh <dist_dir> <app_name>}"
 
-OUTPUT="$DIST_DIR/$APP_NAME-$TARGET"
+OUTPUT="$DIST_DIR/$APP_NAME"
 
 echo ""
-echo "Compiling $APP_NAME for $TARGET..."
+echo "Compiling $APP_NAME..."
 mkdir -p "$DIST_DIR"
 
 deno compile \
   --allow-all \
-  --target "$TARGET" \
+  --no-check \
   --output "$OUTPUT" \
   --include template/ \
-  scheduler.js
+  basecamp.js
 
 echo "  -> $OUTPUT"

package/scripts/install.sh

@@ -61,7 +61,7 @@ fi
 echo ""
 if [ ! -d "$DEFAULT_KB" ]; then
   echo "Initializing default knowledge base at $DEFAULT_KB ..."
-  SCHEDULER="$SCRIPT_DIR/../scheduler.js"
+  SCHEDULER="$SCRIPT_DIR/../basecamp.js"
   if command -v deno &>/dev/null && [ -f "$SCHEDULER" ]; then
     deno run --allow-all "$SCHEDULER" --init "$DEFAULT_KB"
   elif command -v node &>/dev/null && [ -f "$SCHEDULER" ]; then
@@ -79,7 +79,7 @@ fi
 
 echo ""
 echo "Installing background scheduler (LaunchAgent)..."
-SCHEDULER="$SCRIPT_DIR/../scheduler.js"
+SCHEDULER="$SCRIPT_DIR/../basecamp.js"
 if command -v deno &>/dev/null && [ -f "$SCHEDULER" ]; then
   deno run --allow-all "$SCHEDULER" --install-launchd
 elif command -v node &>/dev/null && [ -f "$SCHEDULER" ]; then
@@ -102,7 +102,7 @@ echo ""
 echo "Next steps:"
 echo "  1. Edit $DEFAULT_KB/USER.md with your name, email, and domain"
 echo "  2. Edit $BASECAMP_HOME/scheduler.json to configure tasks"
-echo "  3. Run the scheduler:    deno run --allow-all scheduler.js --status"
-echo "  4. Start the daemon:     deno run --allow-all scheduler.js --install-launchd"
+echo "  3. Run the scheduler:    deno run --allow-all basecamp.js --status"
+echo "  4. Start the daemon:     deno run --allow-all basecamp.js --install-launchd"
 echo "  5. Open your KB:         cd $DEFAULT_KB && claude"
 echo ""

package/scripts/postinstall

@@ -12,6 +12,7 @@ BASECAMP_HOME="$REAL_HOME/.fit/basecamp"
 DEFAULT_KB="$REAL_HOME/Documents/Personal"
 SHARE_DIR="/usr/local/share/fit-basecamp"
 BINARY="/usr/local/bin/fit-basecamp"
+STATUS_MENU_BINARY="/usr/local/bin/BasecampStatus"
 
 # --- Config home -------------------------------------------------------------
 
@@ -43,4 +44,41 @@ else
   /usr/bin/sudo -u "$REAL_USER" "$BINARY" --install-launchd 2>/dev/null || true
 fi
 
+# --- Status menu LaunchAgent (runs as user, not root) -----------------------
+
+STATUS_PLIST="$REAL_HOME/Library/LaunchAgents/com.fit-basecamp.status-menu.plist"
+
+if [ -f "$STATUS_MENU_BINARY" ]; then
+  # Kill old status menu if running (picks up new binary on relaunch)
+  /usr/bin/killall BasecampStatus 2>/dev/null || true
+
+  # Write LaunchAgent plist
+  /usr/bin/sudo -u "$REAL_USER" /usr/bin/tee "$STATUS_PLIST" > /dev/null <<PLIST
+<?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>com.fit-basecamp.status-menu</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/usr/local/bin/BasecampStatus</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>$BASECAMP_HOME/logs/status-menu-stdout.log</string>
+  <key>StandardErrorPath</key>
+  <string>$BASECAMP_HOME/logs/status-menu-stderr.log</string>
+</dict>
+</plist>
+PLIST
+
+  # Load the LaunchAgent (unload first for upgrades)
+  /usr/bin/sudo -u "$REAL_USER" /usr/bin/launchctl unload "$STATUS_PLIST" 2>/dev/null || true
+  /usr/bin/sudo -u "$REAL_USER" /usr/bin/launchctl load "$STATUS_PLIST"
+fi
+
 exit 0

package/scripts/uninstall.sh

@@ -24,6 +24,23 @@ else
   echo "  LaunchAgent not found, skipping."
 fi
 
+# Remove status menu LaunchAgent
+STATUS_PLIST="$HOME/Library/LaunchAgents/com.fit-basecamp.status-menu.plist"
+if [ -f "$STATUS_PLIST" ]; then
+  launchctl unload "$STATUS_PLIST" 2>/dev/null || true
+  rm -f "$STATUS_PLIST"
+  echo "  Removed status menu LaunchAgent"
+fi
+killall BasecampStatus 2>/dev/null || true
+if [ -f "/usr/local/bin/BasecampStatus" ]; then
+  sudo rm -f "/usr/local/bin/BasecampStatus"
+  echo "  Removed /usr/local/bin/BasecampStatus"
+fi
+
+# Remove stale socket file
+# Socket path: ~/.fit/basecamp/basecamp.sock (must match SOCKET_PATH in basecamp.js)
+rm -f "$HOME/.fit/basecamp/basecamp.sock"
+
 # Remove binary
 if [ -f "/usr/local/bin/$APP_NAME" ]; then
   sudo rm -f "/usr/local/bin/$APP_NAME"