@forwardimpact/basecamp 0.1.0 → 0.3.0

package/README.md

@@ -54,14 +54,11 @@ To uninstall, run `/usr/local/share/basecamp/uninstall.sh`.
 
 ```bash
 cd apps/basecamp
-./scripts/install.sh
+./scripts/init.sh
 
 # Configure your identity
 vi ~/Documents/Personal/USER.md
 
-# Start the daemon
-npx fit-basecamp --install-launchd
-
 # Open your KB interactively
 cd ~/Documents/Personal && claude
 ```
@@ -180,13 +177,11 @@ fit-basecamp                     Run due tasks once and exit
 fit-basecamp --daemon            Run continuously (poll every 60s)
 fit-basecamp --run <task>        Run a specific task immediately
 fit-basecamp --init <path>       Initialize a new knowledge base
-fit-basecamp --install-launchd   Install macOS LaunchAgent for auto-start
-fit-basecamp --uninstall-launchd Remove macOS LaunchAgent
 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
@@ -220,7 +215,7 @@ ships with these skills:
 ## Requirements
 
 - Claude CLI (`claude`) installed and authenticated
-- macOS (for Apple Mail/Calendar sync and launchd)
+- macOS (for Apple Mail/Calendar sync)
 - Node.js >= 18 (for running from source) or the standalone binary
 - Deno >= 2.x (for building the standalone binary)
 

package/{scheduler.js → basecamp.js}

@@ -1,17 +1,15 @@
 #!/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 --validate          Validate agents and skills exist
+//   node basecamp.js --status            Show task status
+//   node basecamp.js --help              Show this help
 
 import {
   readFileSync,
@@ -19,26 +17,27 @@ 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");
 const CONFIG_PATH = join(BASECAMP_HOME, "scheduler.json");
 const STATE_PATH = join(BASECAMP_HOME, "state.json");
 const LOG_DIR = join(BASECAMP_HOME, "logs");
-const PLIST_NAME = "com.fit-basecamp.scheduler";
-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 IS_COMPILED =
-  typeof Deno !== "undefined" &&
-  Deno.execPath &&
-  !Deno.execPath().endsWith("deno");
+const SOCKET_PATH = join(BASECAMP_HOME, "basecamp.sock");
+
+let daemonStartedAt = null;
 
 // --- Helpers ----------------------------------------------------------------
 
@@ -152,6 +151,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 +197,247 @@ 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" });
+  setTimeout(() => 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}`);
     }
@@ -299,69 +483,6 @@ function initKB(targetPath) {
   );
 }
 
-// --- LaunchAgent ------------------------------------------------------------
-
-function installLaunchd() {
-  const execPath =
-    typeof Deno !== "undefined" ? Deno.execPath() : process.execPath;
-  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>`;
-
-  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">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${PLIST_NAME}</string>
-  <key>ProgramArguments</key>
-  <array>
-${progArgs}
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${join(LOG_DIR, "launchd-stdout.log")}</string>
-  <key>StandardErrorPath</key>
-  <string>${join(LOG_DIR, "launchd-stderr.log")}</string>
-  <key>WorkingDirectory</key>
-  <string>${BASECAMP_HOME}</string>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>PATH</key>
-    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:${join(HOME, ".local", "bin")}</string>
-  </dict>
-</dict>
-</plist>`;
-
-  ensureDir(dirname(PLIST_PATH));
-  ensureDir(LOG_DIR);
-  writeFileSync(PLIST_PATH, plist);
-
-  try {
-    execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, {
-      stdio: "ignore",
-    });
-  } catch {}
-  execSync(`launchctl load "${PLIST_PATH}"`);
-  console.log(
-    `LaunchAgent installed and loaded.\n  Plist:  ${PLIST_PATH}\n  Logs:   ${LOG_DIR}/\n  Config: ${CONFIG_PATH}`,
-  );
-}
-
-function uninstallLaunchd() {
-  try {
-    execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`);
-  } catch {}
-  try {
-    execSync(`rm -f "${PLIST_PATH}"`);
-  } catch {}
-  console.log("LaunchAgent uninstalled.");
-}
-
 // --- Status -----------------------------------------------------------------
 
 function showStatus() {
@@ -392,15 +513,6 @@ function showStatus() {
     if (s.lastError) lines.push(`    Error: ${s.lastError.slice(0, 80)}`);
     console.log(lines.join("\n"));
   }
-
-  try {
-    execSync(`launchctl list 2>/dev/null | grep ${PLIST_NAME}`, {
-      encoding: "utf8",
-    });
-    console.log("\nLaunchAgent: loaded");
-  } catch {
-    console.log("\nLaunchAgent: not loaded (run --install-launchd to start)");
-  }
 }
 
 // --- Validate ---------------------------------------------------------------
@@ -481,8 +593,6 @@ Usage:
   ${bin} --daemon            Run continuously (poll every 60s)
   ${bin} --run <task>        Run a specific task immediately
   ${bin} --init <path>       Initialize a new knowledge base
-  ${bin} --install-launchd   Install macOS LaunchAgent for auto-start
-  ${bin} --uninstall-launchd Remove macOS LaunchAgent
   ${bin} --validate          Validate agents and skills exist
   ${bin} --status            Show task status
   ${bin} --help              Show this help
@@ -520,20 +630,18 @@ const commands = {
   "--help": showHelp,
   "-h": showHelp,
   "--daemon": daemon,
-  "--install-launchd": installLaunchd,
-  "--uninstall-launchd": uninstallLaunchd,
   "--validate": validate,
   "--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 +653,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,
-  });
+  const buildPkg = join(__dirname, "pkg", "macos", "build-pkg.sh");
+  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.3.0",
   "description": "Claude Code-native personal knowledge system with scheduled tasks",
   "license": "Apache-2.0",
   "repository": {
@@ -10,25 +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"
+    "init": "./scripts/init.sh"
   },
   "files": [
-    "scheduler.js",
+    "basecamp.js",
     "build.js",
     "config/",
-    "scripts/",
     "template/"
   ],
   "engines": {

package/scripts/build-pkg.sh

@@ -1,117 +0,0 @@
-#!/bin/bash
-set -e
-
-# Build a macOS installer package (.pkg) for Basecamp.
-#
-# 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
-
-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>}"
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
-BINARY_PATH="$DIST_DIR/$APP_NAME-$TARGET"
-IDENTIFIER="com.fit-basecamp.scheduler"
-
-if [ ! -f "$BINARY_PATH" ]; then
-  echo "Error: binary not found at $BINARY_PATH"
-  echo "Run compile.sh first."
-  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_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"
-
-echo ""
-echo "Building pkg: $PKG_NAME..."
-
-# --- Clean previous artifacts ------------------------------------------------
-
-rm -rf "$PAYLOAD_DIR" "$SCRIPTS_DIR" "$RESOURCES_DIR" "$COMPONENT_PKG"
-rm -f "$PKG_PATH"
-
-# --- Create payload (files to install) ---------------------------------------
-
-mkdir -p "$PAYLOAD_DIR/usr/local/bin"
-mkdir -p "$PAYLOAD_DIR/usr/local/share/fit-basecamp/config"
-
-cp "$BINARY_PATH" "$PAYLOAD_DIR/usr/local/bin/$APP_NAME"
-chmod +x "$PAYLOAD_DIR/usr/local/bin/$APP_NAME"
-
-cp "$PROJECT_DIR/config/scheduler.json" "$PAYLOAD_DIR/usr/local/share/fit-basecamp/config/scheduler.json"
-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"
-
-# --- Create scripts directory ------------------------------------------------
-
-mkdir -p "$SCRIPTS_DIR"
-cp "$SCRIPT_DIR/postinstall" "$SCRIPTS_DIR/postinstall"
-chmod +x "$SCRIPTS_DIR/postinstall"
-
-# --- Build component package -------------------------------------------------
-
-pkgbuild \
-  --root "$PAYLOAD_DIR" \
-  --scripts "$SCRIPTS_DIR" \
-  --identifier "$IDENTIFIER" \
-  --version "$VERSION" \
-  --install-location "/" \
-  "$COMPONENT_PKG"
-
-# --- Create distribution resources -------------------------------------------
-
-mkdir -p "$RESOURCES_DIR"
-cp "$SCRIPT_DIR/pkg-resources/welcome.html" "$RESOURCES_DIR/welcome.html"
-cp "$SCRIPT_DIR/pkg-resources/conclusion.html" "$RESOURCES_DIR/conclusion.html"
-
-# --- Create distribution.xml ------------------------------------------------
-
-DIST_XML="$DIST_DIR/distribution-$ARCH_SHORT.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" />
-    <domains enable_localSystem="true" />
-    <pkg-ref id="$IDENTIFIER" version="$VERSION">pkg-component-$ARCH_SHORT.pkg</pkg-ref>
-    <choices-outline>
-        <line choice="$IDENTIFIER" />
-    </choices-outline>
-    <choice id="$IDENTIFIER" visible="false">
-        <pkg-ref id="$IDENTIFIER" />
-    </choice>
-</installer-gui-script>
-EOF
-
-# --- Build distribution package ----------------------------------------------
-
-productbuild \
-  --distribution "$DIST_XML" \
-  --resources "$RESOURCES_DIR" \
-  --package-path "$DIST_DIR" \
-  "$PKG_PATH"
-
-# --- Clean up staging --------------------------------------------------------
-
-rm -rf "$PAYLOAD_DIR" "$SCRIPTS_DIR" "$RESOURCES_DIR" "$COMPONENT_PKG" "$DIST_XML"
-
-echo "  -> $PKG_PATH"

package/scripts/compile.sh

@@ -1,26 +0,0 @@
-#!/bin/bash
-set -e
-
-# Compile Basecamp into a standalone Deno binary.
-#
-# Usage: compile.sh <dist_dir> <app_name> <target>
-#   e.g.  compile.sh dist basecamp aarch64-apple-darwin
-
-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>}"
-
-OUTPUT="$DIST_DIR/$APP_NAME-$TARGET"
-
-echo ""
-echo "Compiling $APP_NAME for $TARGET..."
-mkdir -p "$DIST_DIR"
-
-deno compile \
-  --allow-all \
-  --target "$TARGET" \
-  --output "$OUTPUT" \
-  --include template/ \
-  scheduler.js
-
-echo "  -> $OUTPUT"

package/scripts/install.sh

@@ -1,108 +0,0 @@
-#!/bin/bash
-set -e
-
-# Basecamp Installer (development / repo context)
-#
-# Sets up scheduler config, default knowledge base, and LaunchAgent for local
-# development. The compiled binary is installed via the .pkg installer instead.
-#
-# This script is for engineers running from the repo with deno or node.
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-APP_NAME="fit-basecamp"
-BASECAMP_HOME="$HOME/.fit/basecamp"
-DEFAULT_KB="$HOME/Documents/Personal"
-
-echo ""
-echo "Basecamp Installer (dev)"
-echo "========================"
-echo ""
-
-# ---------------------------------------------------------------------------
-# 1. Set up scheduler home
-# ---------------------------------------------------------------------------
-
-echo "Setting up scheduler home at $BASECAMP_HOME ..."
-mkdir -p "$BASECAMP_HOME/logs"
-
-# ---------------------------------------------------------------------------
-# 2. Copy scheduler config (single source of truth: config/scheduler.json)
-# ---------------------------------------------------------------------------
-
-CONFIG_SRC=""
-if [ -f "$SCRIPT_DIR/../config/scheduler.json" ]; then
-  CONFIG_SRC="$SCRIPT_DIR/../config/scheduler.json"
-fi
-
-if [ ! -f "$BASECAMP_HOME/scheduler.json" ]; then
-  if [ -n "$CONFIG_SRC" ]; then
-    cp "$CONFIG_SRC" "$BASECAMP_HOME/scheduler.json"
-    echo "  Created $BASECAMP_HOME/scheduler.json"
-  else
-    echo "  Warning: config/scheduler.json not found, skipping config setup."
-  fi
-else
-  echo "  Scheduler config already exists, skipping."
-fi
-
-# ---------------------------------------------------------------------------
-# 3. Initialize state file
-# ---------------------------------------------------------------------------
-
-if [ ! -f "$BASECAMP_HOME/state.json" ]; then
-  echo '{ "tasks": {} }' > "$BASECAMP_HOME/state.json"
-  echo "  Created $BASECAMP_HOME/state.json"
-fi
-
-# ---------------------------------------------------------------------------
-# 4. Initialize default knowledge base
-# ---------------------------------------------------------------------------
-
-echo ""
-if [ ! -d "$DEFAULT_KB" ]; then
-  echo "Initializing default knowledge base at $DEFAULT_KB ..."
-  SCHEDULER="$SCRIPT_DIR/../scheduler.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
-    node "$SCHEDULER" --init "$DEFAULT_KB"
-  else
-    echo "  Neither deno nor node found, skipping KB initialization."
-  fi
-else
-  echo "Basecamp already initialized at $DEFAULT_KB/"
-fi
-
-# ---------------------------------------------------------------------------
-# 5. Install LaunchAgent
-# ---------------------------------------------------------------------------
-
-echo ""
-echo "Installing background scheduler (LaunchAgent)..."
-SCHEDULER="$SCRIPT_DIR/../scheduler.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
-  node "$SCHEDULER" --install-launchd
-else
-  echo "  Neither deno nor node found, skipping LaunchAgent install."
-fi
-
-# ---------------------------------------------------------------------------
-# Summary
-# ---------------------------------------------------------------------------
-
-echo ""
-echo "Done! Basecamp is installed."
-echo ""
-echo "  Config:       $BASECAMP_HOME/scheduler.json"
-echo "  Knowledge:    $DEFAULT_KB/"
-echo "  Logs:         $BASECAMP_HOME/logs/"
-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 "  5. Open your KB:         cd $DEFAULT_KB && claude"
-echo ""

package/scripts/pkg-resources/conclusion.html

@@ -1,62 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <style>
-      body {
-        font-family:
-          -apple-system,
-          Helvetica Neue,
-          sans-serif;
-        padding: 20px;
-        color: #1d1d1f;
-      }
-      h1 {
-        font-size: 22px;
-        font-weight: 600;
-        margin-bottom: 16px;
-      }
-      p {
-        font-size: 14px;
-        line-height: 1.6;
-        color: #424245;
-      }
-      code {
-        font-family:
-          SF Mono,
-          Menlo,
-          monospace;
-        font-size: 13px;
-        background: #f5f5f7;
-        padding: 2px 6px;
-        border-radius: 4px;
-      }
-      .cmd {
-        margin: 8px 0 8px 16px;
-      }
-      .note {
-        font-size: 12px;
-        color: #86868b;
-        margin-top: 20px;
-      }
-    </style>
-  </head>
-  <body>
-    <h1>Basecamp is installed</h1>
-    <p>
-      The scheduler is running in the background and will start automatically on
-      login.
-    </p>
-    <p><strong>Next steps:</strong></p>
-    <p>1. Edit your identity file:</p>
-    <p class="cmd"><code>vim ~/Documents/Personal/USER.md</code></p>
-    <p>2. Configure scheduled tasks:</p>
-    <p class="cmd"><code>vim ~/.fit/basecamp/scheduler.json</code></p>
-    <p>3. Check scheduler status:</p>
-    <p class="cmd"><code>fit-basecamp --status</code></p>
-    <p>4. Open your knowledge base interactively:</p>
-    <p class="cmd"><code>cd ~/Documents/Personal &amp;&amp; claude</code></p>
-    <p class="note">
-      To uninstall, run: <code>/usr/local/share/fit-basecamp/uninstall.sh</code>
-    </p>
-  </body>
-</html>

package/scripts/pkg-resources/welcome.html

@@ -1,64 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <style>
-      body {
-        font-family:
-          -apple-system,
-          Helvetica Neue,
-          sans-serif;
-        padding: 20px;
-        color: #1d1d1f;
-      }
-      h1 {
-        font-size: 22px;
-        font-weight: 600;
-        margin-bottom: 16px;
-      }
-      p {
-        font-size: 14px;
-        line-height: 1.6;
-        color: #424245;
-      }
-      ul {
-        font-size: 14px;
-        line-height: 1.8;
-        color: #424245;
-        padding-left: 20px;
-      }
-      .note {
-        font-size: 12px;
-        color: #86868b;
-        margin-top: 20px;
-      }
-    </style>
-  </head>
-  <body>
-    <h1>Basecamp</h1>
-    <p>
-      Personal knowledge system with scheduled AI tasks. No server, no database.
-      just plain files, markdown, and Claude Code.
-    </p>
-    <p>This installer will:</p>
-    <ul>
-      <li>
-        Install the <code>fit-basecamp</code> binary to
-        <code>/usr/local/bin/</code>
-      </li>
-      <li>
-        Set up the scheduler configuration at <code>~/.fit/basecamp/</code>
-      </li>
-      <li>
-        Initialize a default knowledge base at
-        <code>~/Documents/Personal/</code>
-      </li>
-      <li>
-        Install a LaunchAgent so the scheduler runs automatically on login
-      </li>
-    </ul>
-    <p class="note">
-      Requires the Claude Code CLI (<code>claude</code>) to be installed and
-      authenticated.
-    </p>
-  </body>
-</html>

package/scripts/postinstall

@@ -1,46 +0,0 @@
-#!/bin/bash
-
-# Basecamp postinstall script — runs as root after macOS pkg installation.
-#
-# Sets up per-user config, default knowledge base, and LaunchAgent for the
-# console user (the person who double-clicked the installer).
-
-REAL_USER=$(/usr/bin/stat -f "%Su" /dev/console)
-REAL_HOME=$(/usr/bin/dscl . -read "/Users/$REAL_USER" NFSHomeDirectory | /usr/bin/awk '{print $2}')
-
-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"
-
-# --- Config home -------------------------------------------------------------
-
-/usr/bin/sudo -u "$REAL_USER" /bin/mkdir -p "$BASECAMP_HOME/logs"
-
-if [ ! -f "$BASECAMP_HOME/scheduler.json" ] && [ -f "$SHARE_DIR/config/scheduler.json" ]; then
-  /usr/bin/sudo -u "$REAL_USER" /bin/cp "$SHARE_DIR/config/scheduler.json" "$BASECAMP_HOME/scheduler.json"
-fi
-
-if [ ! -f "$BASECAMP_HOME/state.json" ]; then
-  echo '{ "tasks": {} }' | /usr/bin/sudo -u "$REAL_USER" /usr/bin/tee "$BASECAMP_HOME/state.json" > /dev/null
-fi
-
-# --- Default knowledge base --------------------------------------------------
-
-if [ ! -d "$DEFAULT_KB" ]; then
-  /usr/bin/sudo -u "$REAL_USER" "$BINARY" --init "$DEFAULT_KB" 2>/dev/null || true
-fi
-
-# --- LaunchAgent (runs as user, not root) ------------------------------------
-
-PLIST="$REAL_HOME/Library/LaunchAgents/com.fit-basecamp.scheduler.plist"
-if [ -f "$PLIST" ]; then
-  # Upgrade: binary already replaced by pkg payload. Kill the old daemon and
-  # let KeepAlive restart it with the new binary. No plist rewrite needed.
-  /usr/bin/killall fit-basecamp 2>/dev/null || true
-else
-  # Fresh install: create plist and load it.
-  /usr/bin/sudo -u "$REAL_USER" "$BINARY" --install-launchd 2>/dev/null || true
-fi
-
-exit 0

package/scripts/uninstall.sh

@@ -1,56 +0,0 @@
-#!/bin/bash
-set -e
-
-# Basecamp Uninstaller
-#
-# Removes the binary, LaunchAgent, and shared data installed by the .pkg.
-# User data at ~/Documents/Personal/ and config at ~/.fit/basecamp/ are preserved.
-
-APP_NAME="${1:-fit-basecamp}"
-PLIST_NAME="${2:-com.fit-basecamp.scheduler}"
-
-echo ""
-echo "Basecamp Uninstaller"
-echo "====================="
-echo ""
-
-# Remove LaunchAgent
-PLIST="$HOME/Library/LaunchAgents/$PLIST_NAME.plist"
-if [ -f "$PLIST" ]; then
-  launchctl unload "$PLIST" 2>/dev/null || true
-  rm -f "$PLIST"
-  echo "  Removed LaunchAgent"
-else
-  echo "  LaunchAgent not found, skipping."
-fi
-
-# Remove binary
-if [ -f "/usr/local/bin/$APP_NAME" ]; then
-  sudo rm -f "/usr/local/bin/$APP_NAME"
-  echo "  Removed /usr/local/bin/$APP_NAME"
-else
-  echo "  Binary not found at /usr/local/bin/$APP_NAME, skipping."
-fi
-
-# Remove shared data (default config template, this uninstall script's installed copy)
-if [ -d "/usr/local/share/fit-basecamp" ]; then
-  sudo rm -rf "/usr/local/share/fit-basecamp"
-  echo "  Removed /usr/local/share/fit-basecamp/"
-else
-  echo "  Shared data not found, skipping."
-fi
-
-# Forget pkg receipt
-pkgutil --pkgs 2>/dev/null | grep -q "com.fit-basecamp.scheduler" && {
-  sudo pkgutil --forget "com.fit-basecamp.scheduler" >/dev/null 2>&1
-  echo "  Removed installer receipt"
-} || true
-
-echo ""
-echo "Basecamp uninstalled."
-echo "Your data at ~/Documents/Personal/ has been preserved."
-echo "Your config at ~/.fit/basecamp/ has been preserved."
-echo ""
-echo "To remove all data:   rm -rf ~/Documents/Personal/"
-echo "To remove all config: rm -rf ~/.fit/basecamp/"
-echo ""