chapterhouse 0.1.1 → 0.2.0

package/dist/daemon-install.js

@@ -0,0 +1,368 @@
+/**
+ * Persistent user daemon management for Chapterhouse.
+ * Supports macOS (launchd) and Linux (systemd --user).
+ * Generates unit files at install time using the resolved binary path.
+ */
+import { execSync, execFileSync } from "child_process";
+import { existsSync, mkdirSync, writeFileSync, rmSync } from "fs";
+import { join, dirname } from "path";
+import { homedir, platform } from "os";
+/** The launchd label / systemd unit name. */
+export const DAEMON_LABEL = "com.bketelsen.chapterhouse";
+export const DAEMON_UNIT_NAME = "chapterhouse";
+// ─── Path helpers ────────────────────────────────────────────────────────────
+export function getPlatform() {
+    const p = platform();
+    if (p === "darwin")
+        return "darwin";
+    if (p === "linux")
+        return "linux";
+    if (p === "win32")
+        return "windows";
+    return "unsupported";
+}
+/** ~/Library/LaunchAgents/com.bketelsen.chapterhouse.plist */
+export function getPlistPath() {
+    return join(homedir(), "Library", "LaunchAgents", `${DAEMON_LABEL}.plist`);
+}
+/** ~/.config/systemd/user/chapterhouse.service */
+export function getSystemdUnitPath() {
+    return join(homedir(), ".config", "systemd", "user", `${DAEMON_UNIT_NAME}.service`);
+}
+/** ~/Library/Logs/chapterhouse.log */
+export function getMacOSLogPath() {
+    return join(homedir(), "Library", "Logs", "chapterhouse.log");
+}
+/**
+ * Resolve the absolute path of the `chapterhouse` binary.
+ * Falls back to "chapterhouse" (on $PATH) if resolution fails.
+ */
+export function resolveChapterhouseBin() {
+    try {
+        const resolved = execSync("which chapterhouse", { encoding: "utf-8" }).trim();
+        if (resolved)
+            return resolved;
+    }
+    catch {
+        // not on PATH — fall through
+    }
+    // Fallback: use the path of the current Node process argv[1]
+    // (works when running as: node dist/cli.js  OR  /usr/bin/chapterhouse)
+    const argv1 = process.argv[1];
+    if (argv1 && !argv1.endsWith("cli.js"))
+        return argv1;
+    return "chapterhouse";
+}
+/** Generate the launchd plist XML string. */
+export function generatePlist(options) {
+    const label = options.label ?? DAEMON_LABEL;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${label}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${options.binPath}</string>
+        <string>start</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${options.logPath}</string>
+    <key>StandardErrorPath</key>
+    <string>${options.logPath}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${dirname(options.binPath)}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+    </dict>
+</dict>
+</plist>
+`;
+}
+/** Generate the systemd user unit file string. */
+export function generateSystemdUnit(options) {
+    const description = options.description ?? "Chapterhouse AI assistant daemon";
+    const pathDir = dirname(options.binPath);
+    return `[Unit]
+Description=${description}
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${options.binPath} start
+Restart=on-failure
+RestartSec=5s
+Environment="PATH=${pathDir}:/usr/local/bin:/usr/bin:/bin"
+
+[Install]
+WantedBy=default.target
+`;
+}
+// ─── Install / uninstall ──────────────────────────────────────────────────────
+export async function install() {
+    const plat = getPlatform();
+    if (plat === "windows") {
+        console.log("⚠  Windows daemon install is not yet supported.");
+        console.log("   You can run 'chapterhouse start' manually, or use Task Scheduler.");
+        return;
+    }
+    if (plat === "unsupported") {
+        console.error("❌ Unsupported platform. Daemon install is only supported on macOS and Linux.");
+        process.exit(1);
+    }
+    const binPath = resolveChapterhouseBin();
+    if (plat === "darwin") {
+        const plistPath = getPlistPath();
+        const logPath = getMacOSLogPath();
+        // Ensure ~/Library/Logs/ exists (it should, but be safe)
+        mkdirSync(dirname(logPath), { recursive: true });
+        mkdirSync(dirname(plistPath), { recursive: true });
+        const content = generatePlist({ binPath, logPath });
+        writeFileSync(plistPath, content, "utf-8");
+        console.log(`✅ Wrote ${plistPath}`);
+        try {
+            execFileSync("launchctl", ["load", "-w", plistPath], { stdio: "inherit" });
+            console.log("✅ launchd service loaded and enabled.");
+        }
+        catch (err) {
+            console.error("⚠  Could not load the service with launchctl:", err instanceof Error ? err.message : err);
+            console.log(`   Run manually: launchctl load -w ${plistPath}`);
+        }
+    }
+    else {
+        // Linux
+        const unitPath = getSystemdUnitPath();
+        mkdirSync(dirname(unitPath), { recursive: true });
+        const content = generateSystemdUnit({ binPath });
+        writeFileSync(unitPath, content, "utf-8");
+        console.log(`✅ Wrote ${unitPath}`);
+        try {
+            execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
+            execFileSync("systemctl", ["--user", "enable", "--now", DAEMON_UNIT_NAME], { stdio: "inherit" });
+            console.log("✅ systemd user service enabled and started.");
+            console.log("   Logs: journalctl --user -u chapterhouse -f");
+        }
+        catch (err) {
+            console.error("⚠  Could not enable the service with systemctl:", err instanceof Error ? err.message : err);
+            console.log(`   Run manually: systemctl --user daemon-reload && systemctl --user enable --now ${DAEMON_UNIT_NAME}`);
+        }
+    }
+}
+export async function uninstall() {
+    const plat = getPlatform();
+    if (plat === "windows") {
+        console.log("⚠  Windows daemon uninstall is not yet supported.");
+        return;
+    }
+    if (plat === "unsupported") {
+        console.error("❌ Unsupported platform.");
+        process.exit(1);
+    }
+    if (plat === "darwin") {
+        const plistPath = getPlistPath();
+        if (!existsSync(plistPath)) {
+            console.log("ℹ  No launchd plist found. Nothing to uninstall.");
+            return;
+        }
+        try {
+            execFileSync("launchctl", ["unload", "-w", plistPath], { stdio: "inherit" });
+        }
+        catch {
+            // service may already be stopped
+        }
+        rmSync(plistPath);
+        console.log(`✅ Removed ${plistPath}`);
+        console.log("✅ Chapterhouse launchd service uninstalled.");
+    }
+    else {
+        // Linux
+        const unitPath = getSystemdUnitPath();
+        try {
+            execFileSync("systemctl", ["--user", "disable", "--now", DAEMON_UNIT_NAME], { stdio: "inherit" });
+        }
+        catch {
+            // service may already be stopped
+        }
+        if (existsSync(unitPath)) {
+            rmSync(unitPath);
+            console.log(`✅ Removed ${unitPath}`);
+        }
+        else {
+            console.log("ℹ  No systemd unit file found.");
+        }
+        try {
+            execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
+        }
+        catch {
+            // best effort
+        }
+        console.log("✅ Chapterhouse systemd user service uninstalled.");
+    }
+}
+// ─── Service control ─────────────────────────────────────────────────────────
+function launchctlServiceAction(action) {
+    // launchctl start/stop use the label, not the plist path
+    if (action === "restart") {
+        try {
+            execFileSync("launchctl", ["stop", DAEMON_LABEL], { stdio: "inherit" });
+        }
+        catch { /* ignore */ }
+        execFileSync("launchctl", ["start", DAEMON_LABEL], { stdio: "inherit" });
+    }
+    else {
+        execFileSync("launchctl", [action, DAEMON_LABEL], { stdio: "inherit" });
+    }
+}
+function systemctlUserAction(action) {
+    execFileSync("systemctl", ["--user", action, DAEMON_UNIT_NAME], { stdio: "inherit" });
+}
+export async function start() {
+    const plat = getPlatform();
+    checkPlatformOrExit(plat);
+    if (plat === "darwin")
+        launchctlServiceAction("start");
+    else
+        systemctlUserAction("start");
+    console.log("✅ Chapterhouse daemon started.");
+}
+export async function stop() {
+    const plat = getPlatform();
+    checkPlatformOrExit(plat);
+    if (plat === "darwin")
+        launchctlServiceAction("stop");
+    else
+        systemctlUserAction("stop");
+    console.log("✅ Chapterhouse daemon stopped.");
+}
+export async function restart() {
+    const plat = getPlatform();
+    checkPlatformOrExit(plat);
+    if (plat === "darwin")
+        launchctlServiceAction("restart");
+    else
+        systemctlUserAction("restart");
+    console.log("✅ Chapterhouse daemon restarted.");
+}
+// ─── Status ───────────────────────────────────────────────────────────────────
+export async function status() {
+    const plat = getPlatform();
+    if (plat === "windows") {
+        console.log("⚠  Windows daemon status is not yet supported.");
+        return;
+    }
+    if (plat === "unsupported") {
+        console.error("❌ Unsupported platform.");
+        process.exit(1);
+    }
+    if (plat === "darwin") {
+        const plistPath = getPlistPath();
+        const installed = existsSync(plistPath);
+        console.log(`Installed:  ${installed ? "✅ yes" : "❌ no"} ${installed ? `(${plistPath})` : ""}`);
+        if (!installed)
+            return;
+        try {
+            const out = execSync(`launchctl list | grep ${DAEMON_LABEL}`, { encoding: "utf-8" }).trim();
+            if (out) {
+                const [pid, lastExit] = out.split(/\s+/);
+                const running = pid !== "-" && pid !== "0";
+                console.log(`Running:    ${running ? `✅ yes (PID ${pid})` : "❌ no"}`);
+                console.log(`Last exit:  ${lastExit || "—"}`);
+            }
+            else {
+                console.log("Running:    ❌ no (not loaded)");
+            }
+        }
+        catch {
+            console.log("Running:    ❌ no (not loaded)");
+        }
+        console.log(`Log:        ${getMacOSLogPath()}`);
+    }
+    else {
+        const unitPath = getSystemdUnitPath();
+        const installed = existsSync(unitPath);
+        console.log(`Installed:  ${installed ? "✅ yes" : "❌ no"} ${installed ? `(${unitPath})` : ""}`);
+        if (!installed)
+            return;
+        try {
+            execFileSync("systemctl", ["--user", "status", DAEMON_UNIT_NAME], { stdio: "inherit" });
+        }
+        catch {
+            // systemctl status exits non-zero when stopped; output already printed
+        }
+        console.log("Logs:       journalctl --user -u chapterhouse");
+    }
+}
+// ─── Logs ─────────────────────────────────────────────────────────────────────
+export async function logs() {
+    const plat = getPlatform();
+    if (plat === "windows") {
+        console.log("⚠  Windows daemon logs are not yet supported.");
+        return;
+    }
+    if (plat === "unsupported") {
+        console.error("❌ Unsupported platform.");
+        process.exit(1);
+    }
+    if (plat === "darwin") {
+        const logPath = getMacOSLogPath();
+        if (!existsSync(logPath)) {
+            console.log(`No log file found at ${logPath}`);
+            return;
+        }
+        try {
+            execFileSync("tail", ["-f", logPath], { stdio: "inherit" });
+        }
+        catch {
+            // user pressed Ctrl+C — expected
+        }
+    }
+    else {
+        try {
+            execFileSync("journalctl", ["--user", "-u", DAEMON_UNIT_NAME, "-f", "--no-pager"], { stdio: "inherit" });
+        }
+        catch {
+            // user pressed Ctrl+C — expected
+        }
+    }
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function checkPlatformOrExit(plat) {
+    if (plat === "windows") {
+        console.log("⚠  Windows daemon control is not yet supported.");
+        process.exit(0);
+    }
+    if (plat === "unsupported") {
+        console.error("❌ Unsupported platform.");
+        process.exit(1);
+    }
+}
+export function printDaemonHelp() {
+    console.log(`
+chapterhouse daemon — manage the Chapterhouse persistent background service
+
+Usage:
+  chapterhouse daemon <subcommand>
+
+Subcommands:
+  install    Write the launchd plist (macOS) or systemd unit (Linux), enable + start
+  uninstall  Stop, disable, and remove the unit file
+  start      Start the daemon service (without re-enabling)
+  stop       Stop the daemon service
+  restart    Restart the daemon service
+  status     Show installed/running state and log path
+  logs       Tail live daemon logs (Ctrl+C to exit)
+
+Platform mapping:
+  macOS   ~/Library/LaunchAgents/com.bketelsen.chapterhouse.plist
+          Logs: ~/Library/Logs/chapterhouse.log
+  Linux   ~/.config/systemd/user/chapterhouse.service
+          Logs: journalctl --user -u chapterhouse
+  Windows (not yet supported)
+  `.trim());
+}
+//# sourceMappingURL=daemon-install.js.map

package/dist/daemon-install.test.js

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import test from "node:test";
+import { DAEMON_LABEL, DAEMON_UNIT_NAME, getPlistPath, getSystemdUnitPath, getMacOSLogPath, generatePlist, generateSystemdUnit, } from "./daemon-install.js";
+// ─── Path helpers ─────────────────────────────────────────────────────────────
+test("getPlistPath returns expected LaunchAgents path", () => {
+    assert.equal(getPlistPath(), join(homedir(), "Library", "LaunchAgents", "com.bketelsen.chapterhouse.plist"));
+});
+test("getSystemdUnitPath returns expected systemd user path", () => {
+    assert.equal(getSystemdUnitPath(), join(homedir(), ".config", "systemd", "user", "chapterhouse.service"));
+});
+test("getMacOSLogPath returns expected log path", () => {
+    assert.equal(getMacOSLogPath(), join(homedir(), "Library", "Logs", "chapterhouse.log"));
+});
+// ─── Plist content generation ─────────────────────────────────────────────────
+const MOCK_BIN_DARWIN = "/usr/local/bin/chapterhouse";
+const MOCK_LOG_DARWIN = `${homedir()}/Library/Logs/chapterhouse.log`;
+test("generatePlist contains the correct label", () => {
+    const plist = generatePlist({ binPath: MOCK_BIN_DARWIN, logPath: MOCK_LOG_DARWIN });
+    assert.ok(plist.includes(`<string>${DAEMON_LABEL}</string>`), "plist should contain daemon label");
+});
+test("generatePlist embeds the binary path in ProgramArguments", () => {
+    const plist = generatePlist({ binPath: MOCK_BIN_DARWIN, logPath: MOCK_LOG_DARWIN });
+    assert.ok(plist.includes(`<string>${MOCK_BIN_DARWIN}</string>`), "plist should embed binary path");
+    assert.ok(plist.includes("<string>start</string>"), "plist should pass 'start' argument");
+});
+test("generatePlist sets RunAtLoad and KeepAlive to true", () => {
+    const plist = generatePlist({ binPath: MOCK_BIN_DARWIN, logPath: MOCK_LOG_DARWIN });
+    // RunAtLoad
+    assert.ok(/<key>RunAtLoad<\/key>\s*<true\/>/.test(plist), "plist should set RunAtLoad");
+    // KeepAlive
+    assert.ok(/<key>KeepAlive<\/key>\s*<true\/>/.test(plist), "plist should set KeepAlive");
+});
+test("generatePlist sets StandardOutPath and StandardErrorPath to log path", () => {
+    const plist = generatePlist({ binPath: MOCK_BIN_DARWIN, logPath: MOCK_LOG_DARWIN });
+    const logCount = (plist.match(new RegExp(MOCK_LOG_DARWIN.replace(/\//g, "\\/"), "g")) ?? []).length;
+    assert.ok(logCount >= 2, "plist should reference log path for both stdout and stderr");
+});
+test("generatePlist includes bin directory in PATH environment", () => {
+    const plist = generatePlist({ binPath: MOCK_BIN_DARWIN, logPath: MOCK_LOG_DARWIN });
+    assert.ok(plist.includes(dirname(MOCK_BIN_DARWIN)), "plist PATH should include bin directory");
+});
+test("generatePlist respects a custom label override", () => {
+    const customLabel = "com.example.test";
+    const plist = generatePlist({ binPath: MOCK_BIN_DARWIN, logPath: MOCK_LOG_DARWIN, label: customLabel });
+    assert.ok(plist.includes(`<string>${customLabel}</string>`), "plist should use custom label");
+    assert.ok(!plist.includes(`<string>${DAEMON_LABEL}</string>`), "plist should not use default label");
+});
+test("generatePlist produces valid XML declaration", () => {
+    const plist = generatePlist({ binPath: MOCK_BIN_DARWIN, logPath: MOCK_LOG_DARWIN });
+    assert.ok(plist.startsWith('<?xml version="1.0"'), "plist should start with XML declaration");
+    assert.ok(plist.includes("<!DOCTYPE plist"), "plist should include DOCTYPE");
+});
+// ─── Systemd unit content generation ─────────────────────────────────────────
+const MOCK_BIN_LINUX = "/home/user/.local/bin/chapterhouse";
+test("generateSystemdUnit contains ExecStart with binary path and 'start' argument", () => {
+    const unit = generateSystemdUnit({ binPath: MOCK_BIN_LINUX });
+    assert.ok(unit.includes(`ExecStart=${MOCK_BIN_LINUX} start`), "unit should set ExecStart with bin path + start");
+});
+test("generateSystemdUnit sets Restart=on-failure", () => {
+    const unit = generateSystemdUnit({ binPath: MOCK_BIN_LINUX });
+    assert.ok(unit.includes("Restart=on-failure"), "unit should restart on failure");
+});
+test("generateSystemdUnit includes WantedBy=default.target in [Install]", () => {
+    const unit = generateSystemdUnit({ binPath: MOCK_BIN_LINUX });
+    assert.ok(unit.includes("WantedBy=default.target"), "unit should install for default.target");
+});
+test("generateSystemdUnit includes default description", () => {
+    const unit = generateSystemdUnit({ binPath: MOCK_BIN_LINUX });
+    assert.ok(unit.includes("Chapterhouse AI assistant daemon"), "unit should have description");
+});
+test("generateSystemdUnit respects custom description", () => {
+    const unit = generateSystemdUnit({ binPath: MOCK_BIN_LINUX, description: "Custom desc" });
+    assert.ok(unit.includes("Description=Custom desc"), "unit should use custom description");
+});
+test("generateSystemdUnit includes bin directory in PATH", () => {
+    const unit = generateSystemdUnit({ binPath: MOCK_BIN_LINUX });
+    assert.ok(unit.includes(dirname(MOCK_BIN_LINUX)), "unit PATH should include bin directory");
+});
+test("generateSystemdUnit has all three sections", () => {
+    const unit = generateSystemdUnit({ binPath: MOCK_BIN_LINUX });
+    assert.ok(unit.includes("[Unit]"), "unit should have [Unit] section");
+    assert.ok(unit.includes("[Service]"), "unit should have [Service] section");
+    assert.ok(unit.includes("[Install]"), "unit should have [Install] section");
+});
+test("generateSystemdUnit includes Type=simple", () => {
+    const unit = generateSystemdUnit({ binPath: MOCK_BIN_LINUX });
+    assert.ok(unit.includes("Type=simple"), "unit should have Type=simple");
+});
+// ─── Unit name / label constants ─────────────────────────────────────────────
+test("DAEMON_LABEL is com.bketelsen.chapterhouse", () => {
+    assert.equal(DAEMON_LABEL, "com.bketelsen.chapterhouse");
+});
+test("DAEMON_UNIT_NAME is chapterhouse", () => {
+    assert.equal(DAEMON_UNIT_NAME, "chapterhouse");
+});
+//# sourceMappingURL=daemon-install.test.js.map

package/dist/daemon.js

@@ -16,6 +16,8 @@ import { getDisplayHost } from "./api/server-runtime.js";
 import { StandupScheduler } from "./copilot/standup.js";
 import { DecisionsSyncScheduler } from "./squad/mirror.scheduler.js";
 import { registerShutdownSignals } from "./shutdown-signals.js";
+import { logger } from "./util/logger.js";
+const log = logger.child({ module: "daemon" });
 const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 /** Remove orphaned session folders older than 7 days, preserving the current session. */
 function pruneOldSessions() {
@@ -47,11 +49,11 @@ function pruneOldSessions() {
             }
         }
         if (pruned > 0) {
-            console.log(`[chapterhouse] Pruned ${pruned} orphaned session folder(s)`);
+            log.info({ pruned }, "Pruned orphaned session folders");
         }
     }
     catch (err) {
-        console.error("[chapterhouse] Session pruning failed (non-fatal):", err instanceof Error ? err.message : err);
+        log.error({ err: err instanceof Error ? err.message : err }, "Session pruning failed (non-fatal)");
     }
 }
 function truncate(text, max = 200) {
@@ -59,57 +61,57 @@ function truncate(text, max = 200) {
     return oneLine.length > max ? oneLine.slice(0, max) + "…" : oneLine;
 }
 async function main() {
-    console.log("[chapterhouse] Starting Chapterhouse daemon...");
+    log.info("Starting Chapterhouse daemon");
     if (config.selfEditEnabled) {
-        console.log("[chapterhouse] ⚠ Self-edit mode enabled — Chapterhouse can modify his own source code");
+        log.warn("Self-edit mode enabled — Chapterhouse can modify his own source code");
     }
     // Set up message logging to daemon console
     setMessageLogger((direction, source, text) => {
         const arrow = direction === "in" ? "⟶" : "⟵";
         const tag = source.padEnd(8);
-        console.log(`[chapterhouse] ${tag} ${arrow}  ${truncate(text)}`);
+        log.debug({ direction, source, text: truncate(text) }, "chat");
     });
     // Initialize SQLite
     getDb();
-    console.log("[chapterhouse] Database initialized");
+    log.info("Database initialized");
     // Initialize wiki knowledge base
     const wikiIsNew = ensureWikiStructure();
     if (wikiIsNew) {
-        console.log("[chapterhouse] Created wiki at ~/.chapterhouse/wiki/");
+        log.info("Created wiki");
     }
     if (config.chapterhouseMode === "team") {
         const seed = seedTeamWiki();
         if (seed.created.length > 0) {
-            console.log(`[chapterhouse] Seeded ${seed.created.length} team wiki page(s): ${seed.created.join(", ")}`);
+            log.info({ pages: seed.created }, "Seeded team wiki pages");
         }
     }
     if (shouldMigrate()) {
-        console.log("[chapterhouse] Migrating SQLite memories to wiki...");
+        log.info("Migrating SQLite memories to wiki");
         const count = migrateMemoriesToWiki();
-        console.log(`[chapterhouse] Migrated ${count} memories to wiki`);
+        log.info({ count }, "Migrated memories to wiki");
     }
     if (shouldReorganize()) {
-        console.log("[chapterhouse] Reorganizing wiki pages into entity structure...");
+        log.info("Reorganizing wiki pages into entity structure");
         const count = reorganizeWiki();
-        console.log(`[chapterhouse] Created ${count} entity pages`);
+        log.info({ count }, "Created entity pages during reorganization");
     }
     // Prune orphaned session folders older than 7 days
     pruneOldSessions();
     // One-time deprecation note for legacy Telegram users (v1 → v2)
     if (process.env.TELEGRAM_BOT_TOKEN) {
-        console.log("[chapterhouse] ℹ TELEGRAM_BOT_TOKEN found in env — Telegram support was removed in v2. The web UI is now the only client. You can delete this line from ~/.chapterhouse/.env.");
+        log.warn("TELEGRAM_BOT_TOKEN found in env — Telegram support was removed in v2. The web UI is now the only client.");
     }
     // Start Copilot SDK client
-    console.log("[chapterhouse] Starting Copilot SDK client...");
+    log.info("Starting Copilot SDK client");
     const client = await getClient();
-    console.log("[chapterhouse] Copilot SDK client ready");
+    log.info("Copilot SDK client ready");
     // Initialize orchestrator session
-    console.log("[chapterhouse] Creating orchestrator session...");
+    log.info("Creating orchestrator session");
     await initOrchestrator(client);
-    console.log("[chapterhouse] Orchestrator session ready");
+    log.info("Orchestrator session ready");
     // Wire up proactive notifications — broadcast to all connected web clients
     setProactiveNotify((text) => {
-        console.log(`[chapterhouse] bg-notify ⟵  ${truncate(text)}`);
+        log.debug({ text: truncate(text) }, "bg-notify");
         broadcastToSSE(text);
     });
     // Start HTTP API + serve the web UI
@@ -121,7 +123,7 @@ async function main() {
     decisionsSyncScheduler = new DecisionsSyncScheduler();
     decisionsSyncScheduler.start();
     const url = `http://${getDisplayHost(config.apiHost)}:${config.apiPort}`;
-    console.log(`[chapterhouse] Chapterhouse is fully operational — open ${url} in your browser`);
+    log.info({ url }, "Chapterhouse is fully operational");
     if (process.env.CHAPTERHOUSE_OPEN_BROWSER === "1") {
         const opener = process.platform === "darwin" ? "open" :
             process.platform === "win32" ? "explorer.exe" : "xdg-open";
@@ -129,14 +131,14 @@ async function main() {
             spawn(opener, [url], { detached: true, stdio: "ignore" }).unref();
         }
         catch (err) {
-            console.error(`[chapterhouse] Could not open browser:`, err instanceof Error ? err.message : err);
+            log.warn({ err: err instanceof Error ? err.message : err }, "Could not open browser");
         }
     }
     // Non-blocking update check
     checkForUpdate()
         .then(({ updateAvailable, current, latest }) => {
         if (updateAvailable) {
-            console.log(`[chapterhouse] ⬆ Update available: v${current} → v${latest}  —  run 'chapterhouse update' to install`);
+            log.info({ current, latest }, "Update available — run 'chapterhouse update' to install");
         }
     })
         .catch(() => { }); // silent — network may be unavailable
@@ -149,23 +151,23 @@ let shutdownState = "idle";
 let decisionsSyncScheduler;
 async function shutdown() {
     if (shutdownState === "shutting_down") {
-        console.log("\n[chapterhouse] Forced exit.");
+        log.warn("Forced exit");
         process.exit(1);
     }
     // Check for running workers before shutting down
     const workers = getAgentInfo();
     if (workers.length > 0 && shutdownState === "idle") {
         const names = workers.map(w => `@${w.slug}`).join(", ");
-        console.log(`\n[chapterhouse] ⚠ ${workers.length} running worker(s) will be stopped: ${names}`);
-        console.log("[chapterhouse] Press Ctrl+C again to shut down, or wait for workers to finish.");
+        log.warn({ workerCount: workers.length, workers: names }, "Running workers will be stopped on shutdown");
+        log.warn("Press Ctrl+C again to shut down, or wait for workers to finish");
         shutdownState = "warned";
         return;
     }
     shutdownState = "shutting_down";
-    console.log("\n[chapterhouse] Shutting down... (Ctrl+C again to force)");
+    log.info("Shutting down (Ctrl+C again to force)");
     // Force exit after 3 seconds no matter what
     const forceTimer = setTimeout(() => {
-        console.log("[chapterhouse] Shutdown timed out — forcing exit.");
+        log.warn("Shutdown timed out — forcing exit");
         process.exit(1);
     }, 3000);
     forceTimer.unref();
@@ -184,15 +186,15 @@ async function shutdown() {
     }
     catch { /* best effort */ }
     closeDb();
-    console.log("[chapterhouse] Goodbye.");
+    log.info("Goodbye");
     process.exit(0);
 }
 /** Restart the daemon by spawning a new process and exiting. */
 export async function restartDaemon() {
-    console.log("[chapterhouse] Restarting...");
+    log.info("Restarting");
     const workers = getAgentInfo();
     if (workers.length > 0) {
-        console.log(`[chapterhouse] ⚠ Stopping ${workers.length} running worker(s) for restart`);
+        log.warn({ workerCount: workers.length }, "Stopping running workers for restart");
     }
     // Destroy all active agent sessions
     await shutdownAgents();
@@ -216,20 +218,20 @@ export async function restartDaemon() {
         env: { ...process.env, CHAPTERHOUSE_RESTARTED: "1" },
     });
     child.unref();
-    console.log("[chapterhouse] New process spawned. Exiting old process.");
+    log.info("New process spawned. Exiting old process");
     process.exit(0);
 }
 registerShutdownSignals(process, shutdown);
 // Prevent unhandled errors from crashing the daemon
 process.on("unhandledRejection", (reason) => {
-    console.error("[chapterhouse] Unhandled rejection (kept alive):", reason);
+    log.error({ reason: String(reason) }, "Unhandled rejection (kept alive)");
 });
 process.on("uncaughtException", (err) => {
-    console.error("[chapterhouse] Uncaught exception — shutting down:", err);
+    log.error({ err: err instanceof Error ? err.message : err }, "Uncaught exception — shutting down");
     process.exit(1);
 });
 main().catch((err) => {
-    console.error("[chapterhouse] Fatal error:", err);
+    log.error({ err: err instanceof Error ? err.message : err }, "Fatal error");
     process.exit(1);
 });
 //# sourceMappingURL=daemon.js.map