@forwardimpact/basecamp 1.0.0 → 2.0.0

package/README.md

@@ -65,7 +65,7 @@ To uninstall, run `just uninstall` from the source tree.
 ## Install from Source
 
 ```bash
-cd apps/basecamp
+cd products/basecamp
 
 # Run the scheduler in dev mode
 just daemon

package/config/scheduler.json

@@ -1,28 +1,24 @@
 {
-  "tasks": {
-    "sync-apple-mail": {
+  "agents": {
+    "postman": {
       "kb": "~/Documents/Personal",
       "schedule": { "type": "interval", "minutes": 5 },
-      "enabled": true,
-      "agent": null,
-      "skill": "sync-apple-mail",
-      "prompt": "Sync Apple Mail. Only process new threads since last sync."
+      "enabled": true
     },
-    "sync-apple-calendar": {
+    "concierge": {
       "kb": "~/Documents/Personal",
-      "schedule": { "type": "interval", "minutes": 5 },
-      "enabled": true,
-      "agent": null,
-      "skill": "sync-apple-calendar",
-      "prompt": "Sync Apple Calendar events. Export events from the past 14 days and next 14 days."
+      "schedule": { "type": "interval", "minutes": 10 },
+      "enabled": true
     },
-    "extract-entities": {
+    "librarian": {
       "kb": "~/Documents/Personal",
       "schedule": { "type": "interval", "minutes": 15 },
-      "enabled": true,
-      "agent": null,
-      "skill": "extract-entities",
-      "prompt": "Process any new synced data (emails and calendar events) into knowledge graph notes."
+      "enabled": true
+    },
+    "chief-of-staff": {
+      "kb": "~/Documents/Personal",
+      "schedule": { "type": "cron", "expression": "0 7,18 * * *" },
+      "enabled": true
     }
   }
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@forwardimpact/basecamp",
-  "version": "1.0.0",
-  "description": "Claude Code-native personal knowledge system with scheduled tasks",
+  "version": "2.0.0",
+  "description": "Claude Code-native personal knowledge system with autonomous agents",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/forwardimpact/monorepo",
-    "directory": "apps/basecamp"
+    "directory": "products/basecamp"
   },
   "homepage": "https://www.forwardimpact.team/basecamp",
   "type": "module",

package/src/basecamp.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
-// Basecamp — CLI and scheduler for personal knowledge bases.
+// Basecamp — CLI and scheduler for autonomous agent teams.
 //
 // Usage:
-//   node basecamp.js                     Run due tasks once and exit
+//   node basecamp.js                     Wake due agents 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 --wake <agent>      Wake a specific agent 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 --validate          Validate agent definitions exist
+//   node basecamp.js --status            Show agent status
 //   node basecamp.js --help              Show this help
 
 import {
@@ -18,9 +18,10 @@ import {
   mkdirSync,
   unlinkSync,
   chmodSync,
+  readdirSync,
+  statSync,
 } 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";
@@ -31,28 +32,22 @@ 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 CACHE_DIR = join(HOME, ".cache", "fit", "basecamp");
 const __dirname =
   import.meta.dirname || dirname(fileURLToPath(import.meta.url));
 const SHARE_DIR = "/usr/local/share/fit-basecamp";
 const SOCKET_PATH = join(BASECAMP_HOME, "basecamp.sock");
 
-// --- posix_spawn (macOS app bundle only) ------------------------------------
+// --- posix_spawn (TCC-compliant process spawning) ---------------------------
 
-const USE_POSIX_SPAWN = !!process.env.BASECAMP_BUNDLE;
-let posixSpawn;
-if (USE_POSIX_SPAWN) {
-  try {
-    posixSpawn = await import("./posix-spawn.js");
-  } catch (err) {
-    console.error(
-      "Failed to load posix-spawn, falling back to child_process:",
-      err.message,
-    );
-  }
-}
+import * as posixSpawn from "./posix-spawn.js";
 
 let daemonStartedAt = null;
 
+// Maximum time an agent can be "active" before being considered stale (35 min).
+// Matches the 30-minute child_process timeout plus a buffer.
+const MAX_AGENT_RUNTIME_MS = 35 * 60_000;
+
 // --- Helpers ----------------------------------------------------------------
 
 function ensureDir(dir) {
@@ -124,12 +119,12 @@ function getBundlePath() {
 }
 
 function loadConfig() {
-  return readJSON(CONFIG_PATH, { tasks: {} });
+  return readJSON(CONFIG_PATH, { agents: {} });
 }
 function loadState() {
   const raw = readJSON(STATE_PATH, null);
-  if (!raw || typeof raw !== "object" || !raw.tasks) {
-    const state = { tasks: {} };
+  if (!raw || typeof raw !== "object" || !raw.agents) {
+    const state = { agents: {} };
     saveState(state);
     return state;
   }
@@ -176,187 +171,193 @@ function floorToMinute(d) {
   ).getTime();
 }
 
-function shouldRun(task, taskState, now) {
-  if (task.enabled === false) return false;
-  if (taskState.status === "running") return false;
-  const { schedule } = task;
+function shouldWake(agent, agentState, now) {
+  if (agent.enabled === false) return false;
+  if (agentState.status === "active") return false;
+  const { schedule } = agent;
   if (!schedule) return false;
-  const lastRun = taskState.lastRunAt ? new Date(taskState.lastRunAt) : null;
+  const lastWoke = agentState.lastWokeAt
+    ? new Date(agentState.lastWokeAt)
+    : null;
 
   if (schedule.type === "cron") {
-    if (lastRun && floorToMinute(lastRun) === floorToMinute(now)) return false;
+    if (lastWoke && floorToMinute(lastWoke) === floorToMinute(now))
+      return false;
     return cronMatches(schedule.expression, now);
   }
   if (schedule.type === "interval") {
     const ms = (schedule.minutes || 5) * 60_000;
-    return !lastRun || now.getTime() - lastRun.getTime() >= ms;
+    return !lastWoke || now.getTime() - lastWoke.getTime() >= ms;
   }
   if (schedule.type === "once") {
-    return !taskState.lastRunAt && now >= new Date(schedule.runAt);
+    return !agentState.lastWokeAt && now >= new Date(schedule.runAt);
   }
   return false;
 }
 
-// --- Task execution ---------------------------------------------------------
+// --- Agent execution --------------------------------------------------------
 
-async function runTask(taskName, task, _config, state) {
-  if (!task.kb) {
-    log(`Task ${taskName}: no "kb" specified, skipping.`);
+async function wakeAgent(agentName, agent, _config, state) {
+  if (!agent.kb) {
+    log(`Agent ${agentName}: no "kb" specified, skipping.`);
     return;
   }
-  const kbPath = expandPath(task.kb);
+  const kbPath = expandPath(agent.kb);
   if (!existsSync(kbPath)) {
-    log(`Task ${taskName}: path "${kbPath}" does not exist, skipping.`);
+    log(`Agent ${agentName}: path "${kbPath}" does not exist, skipping.`);
     return;
   }
 
   const claude = findClaude();
-  const prompt = task.skill
-    ? `Use the skill "${task.skill}" — ${task.prompt || `Run the ${taskName} task.`}`
-    : task.prompt || `Run the ${taskName} task.`;
 
-  log(
-    `Running task: ${taskName} (kb: ${task.kb}${task.agent ? `, agent: ${task.agent}` : ""}${task.skill ? `, skill: ${task.skill}` : ""})`,
-  );
+  log(`Waking agent: ${agentName} (kb: ${agent.kb})`);
 
-  const ts = (state.tasks[taskName] ||= {});
-  ts.status = "running";
-  ts.startedAt = new Date().toISOString();
+  const as = (state.agents[agentName] ||= {});
+  as.status = "active";
+  as.startedAt = new Date().toISOString();
   saveState(state);
 
-  const spawnArgs = ["--print"];
-  if (task.agent) spawnArgs.push("--agent", task.agent);
-  spawnArgs.push("-p", prompt);
+  const spawnArgs = ["--agent", agentName, "--print", "-p", "Observe and act."];
 
-  // Use posix_spawn when running inside the app bundle for TCC inheritance.
-  // Fall back to child_process.spawn for dev mode and other platforms.
-  if (posixSpawn) {
-    try {
-      const { pid, stdoutFd, stderrFd } = posixSpawn.spawn(
-        claude,
-        spawnArgs,
-        undefined,
-        kbPath,
-      );
+  try {
+    const { pid, stdoutFd, stderrFd } = posixSpawn.spawn(
+      claude,
+      spawnArgs,
+      undefined,
+      kbPath,
+    );
 
-      // Read stdout and stderr concurrently to avoid pipe deadlocks,
-      // then wait for the child to exit.
-      const [stdout, stderr] = await Promise.all([
-        posixSpawn.readAll(stdoutFd),
-        posixSpawn.readAll(stderrFd),
-      ]);
-      const exitCode = await posixSpawn.waitForExit(pid);
-
-      if (exitCode === 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 ${exitCode}`;
-        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);
-    } catch (err) {
-      log(`Task ${taskName} failed: ${err.message}`);
-      Object.assign(ts, {
+    // Read stdout and stderr concurrently to avoid pipe deadlocks,
+    // then wait for the child to exit.
+    const [stdout, stderr] = await Promise.all([
+      posixSpawn.readAll(stdoutFd),
+      posixSpawn.readAll(stderrFd),
+    ]);
+    const exitCode = await posixSpawn.waitForExit(pid);
+
+    if (exitCode === 0) {
+      log(`Agent ${agentName} completed. Output: ${stdout.slice(0, 200)}...`);
+      updateAgentState(as, stdout, agentName);
+    } else {
+      const errMsg = stderr || stdout || `Exit code ${exitCode}`;
+      log(`Agent ${agentName} failed: ${errMsg.slice(0, 300)}`);
+      Object.assign(as, {
         status: "failed",
         startedAt: null,
-        lastRunAt: new Date().toISOString(),
-        lastError: err.message.slice(0, 500),
+        lastWokeAt: new Date().toISOString(),
+        lastError: errMsg.slice(0, 500),
       });
-      saveState(state);
     }
-    return;
+    saveState(state);
+  } catch (err) {
+    log(`Agent ${agentName} failed: ${err.message}`);
+    Object.assign(as, {
+      status: "failed",
+      startedAt: null,
+      lastWokeAt: new Date().toISOString(),
+      lastError: err.message.slice(0, 500),
+    });
+    saveState(state);
   }
+}
 
-  return new Promise((resolve) => {
-    const child = spawn(claude, spawnArgs, {
-      cwd: kbPath,
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 30 * 60_000,
-    });
+/**
+ * Parse Decision:/Action: lines from agent output and update state.
+ * Also saves stdout to the state directory as a briefing fallback.
+ * @param {object} agentState
+ * @param {string} stdout
+ * @param {string} agentName
+ */
+function updateAgentState(agentState, stdout, agentName) {
+  const lines = stdout.split("\n");
+  const decisionLine = lines.find((l) => l.startsWith("Decision:"));
+  const actionLine = lines.find((l) => l.startsWith("Action:"));
+
+  Object.assign(agentState, {
+    status: "idle",
+    startedAt: null,
+    lastWokeAt: new Date().toISOString(),
+    lastDecision: decisionLine
+      ? decisionLine.slice(10).trim()
+      : stdout.slice(0, 200),
+    lastAction: actionLine ? actionLine.slice(8).trim() : null,
+    lastError: null,
+    wakeCount: (agentState.wakeCount || 0) + 1,
+  });
 
-    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();
-    });
+  // Save output as briefing fallback so View Briefing always has content
+  const stateDir = join(CACHE_DIR, "state");
+  ensureDir(stateDir);
+  const prefix = agentName.replace(/-/g, "_");
+  writeFileSync(join(stateDir, `${prefix}_last_output.md`), stdout);
+}
 
-    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();
+/**
+ * Reset agents stuck in "active" state. This happens when the daemon
+ * restarts while agents were running, or when a child process exits
+ * without triggering cleanup (e.g. pipe error, signal).
+ *
+ * @param {object} state
+ * @param {{ reason: string, maxAge?: number }} opts
+ *   reason  — logged and stored in lastError
+ *   maxAge  — if set, only reset agents active longer than this (ms)
+ */
+function resetStaleAgents(state, { reason, maxAge }) {
+  let resetCount = 0;
+  for (const [name, as] of Object.entries(state.agents)) {
+    if (as.status !== "active") continue;
+    if (maxAge && as.startedAt) {
+      const elapsed = Date.now() - new Date(as.startedAt).getTime();
+      if (elapsed < maxAge) continue;
+    }
+    log(`Resetting stale agent: ${name} (${reason})`);
+    Object.assign(as, {
+      status: "interrupted",
+      startedAt: null,
+      lastError: reason,
     });
-  });
+    resetCount++;
+  }
+  if (resetCount > 0) saveState(state);
+  return resetCount;
 }
 
-async function runDueTasks() {
+async function wakeDueAgents() {
   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)) {
-      await runTask(name, task, config, state);
-      ranAny = true;
+
+  // Reset agents that have been active longer than the maximum runtime.
+  resetStaleAgents(state, {
+    reason: "Exceeded maximum runtime",
+    maxAge: MAX_AGENT_RUNTIME_MS,
+  });
+
+  let wokeAny = false;
+  for (const [name, agent] of Object.entries(config.agents)) {
+    if (shouldWake(agent, state.agents[name] || {}, now)) {
+      await wakeAgent(name, agent, config, state);
+      wokeAny = true;
     }
   }
-  if (!ranAny) log("No tasks due.");
+  if (!wokeAny) log("No agents due.");
 }
 
-// --- Next-run computation ---------------------------------------------------
+// --- Next-wake computation --------------------------------------------------
 
-/** @param {object} task @param {object} taskState @param {Date} now */
-function computeNextRunAt(task, taskState, now) {
-  if (task.enabled === false) return null;
-  const { schedule } = task;
+/** @param {object} agent @param {object} agentState @param {Date} now */
+function computeNextWakeAt(agent, agentState, now) {
+  if (agent.enabled === false) return null;
+  const { schedule } = agent;
   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();
+    const lastWoke = agentState.lastWokeAt
+      ? new Date(agentState.lastWokeAt)
+      : null;
+    if (!lastWoke) return now.toISOString();
+    return new Date(lastWoke.getTime() + ms).toISOString();
   }
 
   if (schedule.type === "cron") {
@@ -372,13 +373,56 @@ function computeNextRunAt(task, taskState, now) {
   }
 
   if (schedule.type === "once") {
-    if (taskState.lastRunAt) return null;
+    if (agentState.lastWokeAt) return null;
     return schedule.runAt;
   }
 
   return null;
 }
 
+// --- Briefing file resolution -----------------------------------------------
+
+/**
+ * Resolve the briefing file for an agent by convention:
+ * 1. Scan ~/.cache/fit/basecamp/state/ for files matching {agent_name}_*.md
+ * 2. Fall back to the KB's knowledge/Briefings/ directory (latest .md file)
+ *
+ * @param {string} agentName
+ * @param {object} agentConfig
+ * @returns {string|null}
+ */
+function resolveBriefingFile(agentName, agentConfig) {
+  // 1. Scan state directory for agent-specific files
+  const stateDir = join(CACHE_DIR, "state");
+  if (existsSync(stateDir)) {
+    const prefix = agentName.replace(/-/g, "_") + "_";
+    const matches = readdirSync(stateDir).filter(
+      (f) => f.startsWith(prefix) && f.endsWith(".md"),
+    );
+    if (matches.length === 1) return join(stateDir, matches[0]);
+    if (matches.length > 1) {
+      return matches
+        .map((f) => join(stateDir, f))
+        .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)[0];
+    }
+  }
+
+  // 2. Fall back to KB briefings directory
+  if (agentConfig.kb) {
+    const kbPath = expandPath(agentConfig.kb);
+    const dir = join(kbPath, "knowledge", "Briefings");
+    if (existsSync(dir)) {
+      const files = readdirSync(dir)
+        .filter((f) => f.endsWith(".md"))
+        .sort()
+        .reverse();
+      if (files.length > 0) return join(dir, files[0]);
+    }
+  }
+
+  return null;
+}
+
 // --- Socket server ----------------------------------------------------------
 
 /** @param {import('node:net').Socket} socket @param {object} data */
@@ -392,19 +436,23 @@ 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,
+  const agents = {};
+
+  for (const [name, agent] of Object.entries(config.agents)) {
+    const as = state.agents[name] || {};
+    agents[name] = {
+      enabled: agent.enabled !== false,
+      status: as.status || "never-woken",
+      lastWokeAt: as.lastWokeAt || null,
+      nextWakeAt: computeNextWakeAt(agent, as, now),
+      lastAction: as.lastAction || null,
+      lastDecision: as.lastDecision || null,
+      wakeCount: as.wakeCount || 0,
+      lastError: as.lastError || null,
+      kbPath: agent.kb ? expandPath(agent.kb) : null,
+      briefingFile: resolveBriefingFile(name, agent),
     };
-    if (ts.startedAt) tasks[name].startedAt = ts.startedAt;
+    if (as.startedAt) agents[name].startedAt = as.startedAt;
   }
 
   send(socket, {
@@ -412,7 +460,7 @@ function handleStatusRequest(socket) {
     uptime: daemonStartedAt
       ? Math.floor((Date.now() - daemonStartedAt) / 1000)
       : 0,
-    tasks,
+    agents,
   });
 }
 
@@ -427,23 +475,23 @@ function handleMessage(socket, line) {
 
   if (request.type === "status") return handleStatusRequest(socket);
 
-  if (request.type === "run") {
-    if (!request.task) {
-      send(socket, { type: "error", message: "Missing task name" });
+  if (request.type === "wake") {
+    if (!request.agent) {
+      send(socket, { type: "error", message: "Missing agent name" });
       return;
     }
     const config = loadConfig();
-    const task = config.tasks[request.task];
-    if (!task) {
+    const agent = config.agents[request.agent];
+    if (!agent) {
       send(socket, {
         type: "error",
-        message: `Task not found: ${request.task}`,
+        message: `Agent not found: ${request.agent}`,
       });
       return;
     }
-    send(socket, { type: "ack", command: "run", task: request.task });
+    send(socket, { type: "ack", command: "wake", agent: request.agent });
     const state = loadState();
-    runTask(request.task, task, config, state).catch(() => {});
+    wakeAgent(request.agent, agent, config, state).catch(() => {});
     return;
   }
 
@@ -497,11 +545,16 @@ function daemon() {
   daemonStartedAt = Date.now();
   log("Scheduler daemon started. Polling every 60 seconds.");
   log(`Config: ${CONFIG_PATH}  State: ${STATE_PATH}`);
+
+  // Reset any agents left "active" from a previous daemon session.
+  const state = loadState();
+  resetStaleAgents(state, { reason: "Daemon restarted" });
+
   startSocketServer();
-  runDueTasks().catch((err) => log(`Error: ${err.message}`));
+  wakeDueAgents().catch((err) => log(`Error: ${err.message}`));
   setInterval(async () => {
     try {
-      await runDueTasks();
+      await wakeDueAgents();
     } catch (err) {
       log(`Error: ${err.message}`);
     }
@@ -542,6 +595,7 @@ function initKB(targetPath) {
     "knowledge/Organizations",
     "knowledge/Projects",
     "knowledge/Topics",
+    "knowledge/Briefings",
   ])
     ensureDir(join(dest, d));
 
@@ -559,23 +613,23 @@ function showStatus() {
     state = loadState();
   console.log("\nBasecamp Scheduler\n==================\n");
 
-  const tasks = Object.entries(config.tasks || {});
-  if (tasks.length === 0) {
-    console.log(`No tasks configured.\n\nEdit ${CONFIG_PATH} to add tasks.`);
+  const agents = Object.entries(config.agents || {});
+  if (agents.length === 0) {
+    console.log(`No agents configured.\n\nEdit ${CONFIG_PATH} to add agents.`);
     return;
   }
 
-  console.log("Tasks:");
-  for (const [name, task] of tasks) {
-    const s = state.tasks[name] || {};
+  console.log("Agents:");
+  for (const [name, agent] of agents) {
+    const s = state.agents[name] || {};
     const kbStatus =
-      task.kb && !existsSync(expandPath(task.kb)) ? " (not found)" : "";
+      agent.kb && !existsSync(expandPath(agent.kb)) ? " (not found)" : "";
     console.log(
-      `  ${task.enabled !== false ? "+" : "-"} ${name}\n` +
-        `    KB: ${task.kb || "(none)"}${kbStatus}  Schedule: ${JSON.stringify(task.schedule)}\n` +
-        `    Status: ${s.status || "never-run"}  Last: ${s.lastRunAt ? new Date(s.lastRunAt).toLocaleString() : "never"}  Runs: ${s.runCount || 0}` +
-        (task.agent ? `\n    Agent: ${task.agent}` : "") +
-        (task.skill ? `\n    Skill: ${task.skill}` : "") +
+      `  ${agent.enabled !== false ? "+" : "-"} ${name}\n` +
+        `    KB: ${agent.kb || "(none)"}${kbStatus}  Schedule: ${JSON.stringify(agent.schedule)}\n` +
+        `    Status: ${s.status || "never-woken"}  Last wake: ${s.lastWokeAt ? new Date(s.lastWokeAt).toLocaleString() : "never"}  Wakes: ${s.wakeCount || 0}` +
+        (s.lastAction ? `\n    Last action: ${s.lastAction}` : "") +
+        (s.lastDecision ? `\n    Last decision: ${s.lastDecision}` : "") +
         (s.lastError ? `\n    Error: ${s.lastError.slice(0, 80)}` : ""),
     );
   }
@@ -593,46 +647,34 @@ function findInLocalOrGlobal(kbPath, subPath) {
 
 function validate() {
   const config = loadConfig();
-  const tasks = Object.entries(config.tasks || {});
-  if (tasks.length === 0) {
-    console.log("No tasks configured. Nothing to validate.");
+  const agents = Object.entries(config.agents || {});
+  if (agents.length === 0) {
+    console.log("No agents configured. Nothing to validate.");
     return;
   }
 
-  console.log("\nValidating tasks...\n");
+  console.log("\nValidating agents...\n");
   let errors = 0;
 
-  for (const [name, task] of tasks) {
-    if (!task.kb) {
+  for (const [name, agent] of agents) {
+    if (!agent.kb) {
       console.log(`  [FAIL] ${name}: no "kb" path specified`);
       errors++;
       continue;
     }
-    const kbPath = expandPath(task.kb);
+    const kbPath = expandPath(agent.kb);
     if (!existsSync(kbPath)) {
       console.log(`  [FAIL] ${name}: path not found: ${kbPath}`);
       errors++;
       continue;
     }
 
-    for (const [kind, sub] of [
-      ["agent", task.agent],
-      ["skill", task.skill],
-    ]) {
-      if (!sub) continue;
-      const relPath =
-        kind === "agent"
-          ? join("agents", sub.endsWith(".md") ? sub : sub + ".md")
-          : join("skills", sub, "SKILL.md");
-      const found = findInLocalOrGlobal(kbPath, relPath);
-      console.log(
-        `  [${found ? "OK" : "FAIL"}]  ${name}: ${kind} "${sub}"${found ? "" : " not found"}`,
-      );
-      if (!found) errors++;
-    }
-
-    if (!task.agent && !task.skill)
-      console.log(`  [OK]   ${name}: no agent or skill to validate`);
+    const agentFile = join("agents", name + ".md");
+    const found = findInLocalOrGlobal(kbPath, agentFile);
+    console.log(
+      `  [${found ? "OK" : "FAIL"}]  ${name}: agent definition${found ? "" : " not found"}`,
+    );
+    if (!found) errors++;
   }
 
   console.log(errors > 0 ? `\n${errors} error(s).` : "\nAll OK.");
@@ -644,15 +686,15 @@ function validate() {
 function showHelp() {
   const bin = "fit-basecamp";
   console.log(`
-Basecamp — Run scheduled Claude tasks across knowledge bases.
+Basecamp — Schedule autonomous agents across knowledge bases.
 
 Usage:
-  ${bin}                     Run due tasks once and exit
+  ${bin}                     Wake due agents once and exit
   ${bin} --daemon            Run continuously (poll every 60s)
-  ${bin} --run <task>        Run a specific task immediately
+  ${bin} --wake <agent>      Wake a specific agent immediately
   ${bin} --init <path>       Initialize a new knowledge base
-  ${bin} --validate          Validate agents and skills exist
-  ${bin} --status            Show task status
+  ${bin} --validate          Validate agent definitions exist
+  ${bin} --status            Show agent status
 
 Config:  ~/.fit/basecamp/scheduler.json
 State:   ~/.fit/basecamp/state.json
@@ -679,22 +721,22 @@ const commands = {
     }
     initKB(args[1]);
   },
-  "--run": async () => {
+  "--wake": async () => {
     if (!args[1]) {
-      console.error("Usage: node basecamp.js --run <task-name>");
+      console.error("Usage: node basecamp.js --wake <agent-name>");
       process.exit(1);
     }
     const config = loadConfig(),
       state = loadState(),
-      task = config.tasks[args[1]];
-    if (!task) {
+      agent = config.agents[args[1]];
+    if (!agent) {
       console.error(
-        `Task "${args[1]}" not found. Available: ${Object.keys(config.tasks).join(", ") || "(none)"}`,
+        `Agent "${args[1]}" not found. Available: ${Object.keys(config.agents).join(", ") || "(none)"}`,
       );
       process.exit(1);
     }
-    await runTask(args[1], task, config, state);
+    await wakeAgent(args[1], agent, config, state);
   },
 };
 
-await (commands[command] || runDueTasks)();
+await (commands[command] || wakeDueAgents)();

package/template/.claude/agents/chief-of-staff.md

@@ -0,0 +1,99 @@
+---
+name: chief-of-staff
+description: >
+  The user's executive assistant. Creates daily briefings that synthesize email,
+  calendar, and knowledge graph state into actionable priorities. Woken at
+  key moments (morning, evening) by the Basecamp scheduler.
+model: sonnet
+permissionMode: bypassPermissions
+---
+
+You are the chief of staff — the user's executive assistant. You create daily
+briefings that synthesize everything happening across email, calendar, and the
+knowledge graph into a clear picture of what matters.
+
+## 1. Gather Intelligence
+
+Read the state files from other agents:
+
+1. **Postman:** `~/.cache/fit/basecamp/state/postman_triage.md`
+   - Urgent emails, items needing reply, threads awaiting response
+2. **Concierge:** `~/.cache/fit/basecamp/state/concierge_outlook.md`
+   - Today's meetings, prep status, unprocessed transcripts
+3. **Librarian:** `~/.cache/fit/basecamp/state/librarian_digest.md`
+   - Pending processing, graph size
+
+Also read directly:
+
+4. **Calendar events:** `~/.cache/fit/basecamp/apple_calendar/*.json`
+   - Full event details for today and tomorrow
+5. **Open items:** Search `knowledge/` for unchecked items `- [ ]`
+6. **Pending drafts:** List `drafts/*_draft.md` files
+
+## 2. Determine Briefing Type
+
+Check the current time:
+
+- **Before noon** → Morning briefing
+- **Noon or later** → Evening briefing
+
+## 3. Create Briefing
+
+### Morning Briefing
+
+Write to `knowledge/Briefings/{YYYY-MM-DD}-morning.md`:
+
+```
+# Morning Briefing — {Day, Month Date, Year}
+
+## Today's Schedule
+- {time}: {meeting title} with {attendees} — {prep status}
+- {time}: {meeting title} with {attendees} — {prep status}
+
+## Priority Actions
+1. {Most urgent item — email reply, meeting prep, or deadline}
+2. {Second priority}
+3. {Third priority}
+
+## Inbox
+- {urgent} urgent, {reply} needing reply, {awaiting} awaiting response
+- Key: **{subject}** from {sender} — {why it matters}
+
+## Open Commitments
+- [ ] {commitment} — {context: for whom, by when}
+- [ ] {commitment} — {context}
+
+## Heads Up
+- {Deadline approaching this week}
+- {Email thread gone quiet — sent N days ago, no reply}
+- {Meeting tomorrow that needs prep}
+```
+
+### Evening Briefing
+
+Write to `knowledge/Briefings/{YYYY-MM-DD}-evening.md`:
+
+```
+# Evening Summary — {Day, Month Date, Year}
+
+## What Happened Today
+- {Meeting with X — key decisions, action items}
+- {Emails of note — replies received, threads resolved}
+- {Knowledge graph updates — new contacts, projects}
+
+## Still Outstanding
+- {Priority items from morning not yet addressed}
+- {New urgent items that came in today}
+
+## Tomorrow Preview
+- {First meeting: time, attendees}
+- {Deadlines this week}
+- {Items to prepare}
+```
+
+## 4. Report
+
+```
+Decision: {morning/evening} briefing — {key insight about today}
+Action: Created knowledge/Briefings/{YYYY-MM-DD}-{morning|evening}.md
+```

package/template/.claude/agents/concierge.md

@@ -0,0 +1,76 @@
+---
+name: concierge
+description: >
+  The user's scheduling assistant. Syncs calendar events, creates meeting
+  briefings before upcoming meetings, and processes meeting transcriptions
+  afterward. Woken on a schedule by the Basecamp scheduler.
+model: sonnet
+permissionMode: bypassPermissions
+skills:
+  - sync-apple-calendar
+  - meeting-prep
+  - process-hyprnote
+---
+
+You are the concierge — the user's scheduling assistant. Each time you are
+woken, you ensure the calendar is current, prepare for upcoming meetings, and
+process completed meeting recordings.
+
+## 1. Sync
+
+Run the sync-apple-calendar skill to pull in calendar events.
+
+## 2. Observe
+
+Assess the current state:
+
+1. List upcoming meetings from `~/.cache/fit/basecamp/apple_calendar/`:
+   - Meetings in the next 2 hours (urgent — need prep)
+   - All meetings today (for the outlook)
+   - Tomorrow's first meeting (for awareness)
+2. For each upcoming meeting, check whether a briefing exists:
+   - Search `knowledge/People/` for notes on each attendee
+   - A meeting is "prepped" if the user has recent notes on all key attendees
+3. Check for unprocessed Hyprnote sessions:
+   - Look in `~/Library/Application Support/hyprnote/sessions/`
+   - Check each session's `_memo.md` against
+     `~/.cache/fit/basecamp/state/graph_processed`
+
+Write the calendar outlook to
+`~/.cache/fit/basecamp/state/concierge_outlook.md`:
+
+```
+# Calendar Outlook — {YYYY-MM-DD HH:MM}
+
+## Next Meeting
+**{title}** at {time} with {attendees}
+Prep: {ready / needs briefing}
+
+## Today's Schedule
+- {time}: {title} ({attendees}) — {prep status}
+- {time}: {title} ({attendees}) — {prep status}
+
+## Unprocessed Meetings
+- {session title} ({date}) — transcript available
+
+## Summary
+{count} meetings today, next in {N} min, {prep_count} need prep,
+{unprocessed} transcripts to process
+```
+
+## 3. Act
+
+Choose the single most valuable action:
+
+1. **Meeting prep** — if a meeting is within 2 hours and key attendees lack
+   recent notes, use the meeting-prep skill to create a briefing
+2. **Process transcript** — if unprocessed Hyprnote sessions exist, use the
+   process-hyprnote skill
+3. **Nothing** — if all meetings are prepped and no transcripts pending
+
+After acting, output exactly:
+
+```
+Decision: {what you observed and why you chose this action}
+Action: {what you did, e.g. "meeting-prep for 2pm with Sarah Chen"}
+```

package/template/.claude/agents/librarian.md

@@ -0,0 +1,61 @@
+---
+name: librarian
+description: >
+  The user's knowledge curator. Processes synced data into structured notes,
+  extracts entities, and keeps the knowledge base organized. Woken on a
+  schedule by the Basecamp scheduler.
+model: sonnet
+permissionMode: bypassPermissions
+skills:
+  - extract-entities
+  - organize-files
+---
+
+You are the librarian — the user's knowledge curator. Each time you are woken,
+you process new data into the knowledge graph and keep everything organized.
+
+## 1. Observe
+
+Assess what needs processing:
+
+1.  Check for unprocessed synced files (mail and calendar data):
+
+        python3 scripts/state.py check
+
+    (Run from the extract-entities skill directory:
+    `.claude/skills/extract-entities/`)
+
+2.  Count existing knowledge graph entities:
+
+    ls knowledge/People/ knowledge/Organizations/ knowledge/Projects/
+    knowledge/Topics/ 2>/dev/null | wc -l
+
+Write your digest to `~/.cache/fit/basecamp/state/librarian_digest.md`:
+
+```
+# Knowledge Digest — {YYYY-MM-DD HH:MM}
+
+## Pending Processing
+- {count} unprocessed synced files
+
+## Knowledge Graph
+- {count} People / {count} Organizations / {count} Projects / {count} Topics
+
+## Summary
+{unprocessed} files to process, graph has {total} entities
+```
+
+## 2. Act
+
+Choose the most valuable action:
+
+1. **Entity extraction** — if unprocessed synced files exist, use the
+   extract-entities skill (process up to 10 files)
+2. **Nothing** — if the graph is current
+
+After acting, output exactly:
+
+```
+Decision: {what you observed and why you chose this action}
+Action: {what you did, e.g. "extract-entities on 7 files"}
+```

package/template/.claude/agents/postman.md

@@ -0,0 +1,73 @@
+---
+name: postman
+description: >
+  The user's email gatekeeper. Syncs mail, triages new messages, drafts replies,
+  and tracks threads awaiting response. Woken on a schedule by the Basecamp
+  scheduler.
+model: sonnet
+permissionMode: bypassPermissions
+skills:
+  - sync-apple-mail
+  - draft-emails
+---
+
+You are the postman — the user's email gatekeeper. Each time you are woken by
+the scheduler, you sync mail, triage what's new, and take the most valuable
+action.
+
+## 1. Sync
+
+Check `~/.cache/fit/basecamp/state/apple_mail_last_sync`. If mail was synced
+less than 3 minutes ago, skip to step 2.
+
+Otherwise, run the sync-apple-mail skill to pull in new email threads.
+
+## 2. Triage
+
+Scan email threads in `~/.cache/fit/basecamp/apple_mail/`. Compare against
+`drafts/drafted` and `drafts/ignored` to identify unprocessed threads.
+
+For each unprocessed thread, classify:
+
+- **Urgent** — deadline mentioned, time-sensitive request, escalation, VIP
+  sender (someone with a note in `knowledge/People/` who the user interacts with
+  frequently)
+- **Needs reply** — question asked, action requested, follow-up needed
+- **FYI** — informational, no action needed
+- **Ignore** — newsletter, marketing, automated notification
+
+Also scan `drafts/drafted` for emails the user sent more than 3 days ago where
+no reply has appeared in the thread — these are **awaiting response**.
+
+Write triage results to `~/.cache/fit/basecamp/state/postman_triage.md`:
+
+```
+# Inbox Triage — {YYYY-MM-DD HH:MM}
+
+## Urgent
+- **{subject}** from {sender} — {reason}
+
+## Needs Reply
+- **{subject}** from {sender} — {what's needed}
+
+## Awaiting Response
+- **{subject}** to {recipient} — sent {N} days ago
+
+## Summary
+{total} unread, {urgent} urgent, {reply} need reply, {awaiting} awaiting response
+```
+
+## 3. Act
+
+Choose the single most valuable action:
+
+1. **Draft replies** — if there are urgent or actionable emails without drafts,
+   use the draft-emails skill for the highest-priority thread
+2. **Nothing** — if no emails need attention, report "all current"
+
+After acting, output exactly:
+
+```
+Decision: {what you observed and why you chose this action}
+Action: {what you did, e.g. "draft-emails for thread 123"}
+```

package/template/CLAUDE.md

@@ -69,6 +69,27 @@ This directory is a knowledge base. Everything is relative to this root:
 └── .mcp.json               # MCP server configurations (optional)
 ```
 
+## Agents
+
+This knowledge base is maintained by a team of agents, each defined in
+`.claude/agents/`. They are woken on a schedule by the Basecamp scheduler. Each
+wake, they observe KB state, decide the most valuable action, and execute.
+
+| Agent              | Domain                         | Schedule     | Skills                                              |
+| ------------------ | ------------------------------ | ------------ | --------------------------------------------------- |
+| **postman**        | Email triage and drafts        | Every 5 min  | sync-apple-mail, draft-emails                       |
+| **concierge**      | Meeting prep and transcripts   | Every 10 min | sync-apple-calendar, meeting-prep, process-hyprnote |
+| **librarian**      | Knowledge graph maintenance    | Every 15 min | extract-entities, organize-files                    |
+| **chief-of-staff** | Daily briefings and priorities | 7am, 6pm     | _(reads all state)_                                 |
+
+Agent state files are in `~/.cache/fit/basecamp/state/`:
+
+- `postman_triage.md` — latest email triage
+- `concierge_outlook.md` — today's calendar outlook
+- `librarian_digest.md` — knowledge graph status
+
+Daily briefings are in `knowledge/Briefings/`.
+
 ## Cache Directory (`~/.cache/fit/basecamp/`)
 
 Synced data and runtime state live outside the knowledge base in