privateer-agent 0.6.9 → 0.7.0

package/src/{daemon → harbor}/index.ts

@@ -2,7 +2,7 @@ import type { Server } from "node:net";
 import { readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-// Pi session stack. The daemon MUST be launched after ./boot.ts (env +
+// Pi session stack. The harbor MUST be launched after ./boot.ts (env +
 // attestation dispatcher) — these are evaluated on import.
 import {
   createAgentSessionServices,
@@ -71,15 +71,15 @@ const MAX_CLOUD_PLAINTEXT = 45_000;
 // a stuck graph from pinning a `running` slot forever when the controller wanders off.
 const GATE_TIMEOUT_MS = 5 * 60_000;
 
-interface DaemonConfig {
+interface HarborConfig {
   defaultModel: string;
   webhooks?: Record<string, { url: string; secret?: string; headers?: Record<string, string> }>;
   providers?: Record<string, { apiKey?: string } | undefined>;
 }
 
 // Minimal config read (webhooks + providers-for-redaction + default model). The
-// full config layer is a Phase-7 port; the daemon only needs these fields.
-function loadDaemonConfig(): DaemonConfig {
+// full config layer is a Phase-7 port; the harbor only needs these fields.
+function loadHarborConfig(): HarborConfig {
   try {
     const raw = JSON.parse(readFileSync(configPath(), "utf8"));
     return {
@@ -156,7 +156,7 @@ export function taskControlArgs(spec: TaskSpec): Record<string, unknown> {
   };
 }
 
-export class Daemon {
+export class Harbor {
   private server?: Server;
   private timer?: ReturnType<typeof setInterval>;
   private readonly startedAt = Date.now();
@@ -170,36 +170,36 @@ export class Daemon {
   // socket stays open).
   private lastActivityAt = Date.now();
   // Live, app-drivable sessions spawned on demand (task_spawn). Each has its OWN relay
-  // terminal (task-<uuid>); the daemon just keeps handles so it can reap them on shutdown.
+  // terminal (task-<uuid>); the harbor just keeps handles so it can reap them on shutdown.
   private readonly liveTasks = new Map<string, LiveTaskHandle>();
 
-  // App-facing routine management (list/save/delete/pause/run) over the daemon's
-  // relay. Run-now is injected here since only the daemon can actually fire one;
+  // App-facing routine management (list/save/delete/pause/run) over the harbor's
+  // relay. Run-now is injected here since only the harbor can actually fire one;
   // webhook validation reads config fresh so a just-declared endpoint is honored.
   private readonly routines = makeRoutinesControl({
     defaultCwd: () => process.cwd(),
-    webhookExists: (name) => !!loadDaemonConfig().webhooks?.[name],
+    webhookExists: (name) => !!loadHarborConfig().webhooks?.[name],
     runNow: (routine) => void this.runRoutine(routine),
   });
 
-  // App-facing channel management (list/save/remove) over the daemon's relay. The
-  // channels daemon (channels/run.ts) is a SEPARATE process that may be down, so
+  // App-facing channel management (list/save/remove) over the harbor's relay. The
+  // channels harbor (channels/run.ts) is a SEPARATE process that may be down, so
   // this edits config.json directly; `runningPlatforms` is a best-effort heartbeat
   // read for a live/offline badge, never a dependency. Edits apply on the channels
-  // daemon's next restart (its deliberate fail-safe posture).
+  // harbor's next restart (its deliberate fail-safe posture).
   private readonly channels = makeChannelsControl({
     runningPlatforms: () => readRunningPlatforms(),
   });
 
   // App-facing MCP connector management (list/save/set_enabled/remove) over the
-  // daemon's relay — the daemon is the Node HOST that actually runs the adapter (a
+  // harbor's relay — the harbor is the Node HOST that actually runs the adapter (a
   // phone/web client can't). Edits the SHARED agent/mcp-desktop.json + mcp.json, so a
   // machine has one MCP config whether it was set from the desktop (IPC) or the phone
   // (relay). Tokens ride in a SEALED box (applyMcpSave) — the relay never sees them.
   private readonly mcp = makeMcpControl();
 
-  // App-facing workflow management (list/get/save/remove/run) over the daemon's relay.
-  // Run-now is injected here since only the daemon owns the runner + its seams. A
+  // App-facing workflow management (list/get/save/remove/run) over the harbor's relay.
+  // Run-now is injected here since only the harbor owns the runner + its seams. A
   // workflow can carry a `script` step (RCE if forged), so every mutation is
   // account-signed + verified (guardControl) before reaching this control.
   private readonly workflows = makeWorkflowsControl({
@@ -236,7 +236,7 @@ export class Daemon {
     this.syncRelay();
     void this.flushPendingCloud();
     const count = loadRoutines().filter((r) => r.enabled).length;
-    log(`daemon started (pid ${process.pid}); ${count} enabled routine(s). Tick every ${TICK_MS / 1000}s.`);
+    log(`harbor started (pid ${process.pid}); ${count} enabled routine(s). Tick every ${TICK_MS / 1000}s.`);
     void this.tick();
   }
 
@@ -261,7 +261,7 @@ export class Daemon {
         onInterrupt: () => {},
         // A workflow human_gate / script-approval is surfaced as a select_request; the app
         // answers with select_response (option name) or an approval_response (allow/deny).
-        // Both resolve the pending gate — otherwise the daemon relay ignores approvals.
+        // Both resolve the pending gate — otherwise the harbor relay ignores approvals.
         onApprovalResponse: (id, decision) => this.resolveGate(id, decision === "deny" ? "deny" : "approve"),
         onSelectResponse: (id, value) => this.resolveGate(id, value),
         onControllerAttached: () => this.onControllerAttached(),
@@ -321,20 +321,20 @@ export class Daemon {
           this.controllerAttached = false;
           this.relay?.stop();
           this.relay = undefined;
-          log("relay terminated from the app; staying offline until the daemon restarts");
+          log("relay terminated from the app; staying offline until the harbor restarts");
         },
-        // The account signed this daemon out server-side (revoked from the app's Linked
+        // The account signed this harbor out server-side (revoked from the app's Linked
         // Devices). Beyond ending remote access (onTerminate), this wipes the machine
         // login: drop the relay and clear credentials, so routines/tasks stop cleanly
         // instead of dead-ending on a 401 each run. Stays idle until you /login on this
-        // machine and restart the daemon (the relayTerminated guard, as with onTerminate).
+        // machine and restart the harbor (the relayTerminated guard, as with onTerminate).
         onRevoked: () => {
           this.relayTerminated = true;
           this.controllerAttached = false;
           this.relay?.stop();
           this.relay = undefined;
           handleServerRevoke();
-          log("account signed out from the app (session revoked) — cleared credentials; idle until you run /login on this machine and restart the daemon");
+          log("account signed out from the app (session revoked) — cleared credentials; idle until you run /login on this machine and restart the harbor");
         },
         onStatus: (text) => log(`relay: ${text}`),
         onDisconnected: () => {
@@ -448,7 +448,7 @@ export class Daemon {
     return this.channels.save(withSecrets as any).message;
   }
 
-  // Verify an account-signed mutating control frame (H2) against this daemon's termId,
+  // Verify an account-signed mutating control frame (H2) against this harbor's termId,
   // then run the mutation. Fail-closed: an unsigned/forged/stale frame returns the
   // refusal message and the mutation NEVER runs. `routines_*` and `channels_remove`
   // route through here; `channels_save` has its own verify (sealed secrets) above.
@@ -577,7 +577,7 @@ export class Daemon {
   }
 
   // ── Harbor hosted mode ──────────────────────────────────────────────────────
-  // A hosted daemon runs on-demand: it reports its earliest upcoming fire time so
+  // A hosted harbor runs on-demand: it reports its earliest upcoming fire time so
   // the server can wake it while suspended, and idle-suspends when there's no work.
   // No-op on a user's own machine (isHosted() === false).
 
@@ -652,7 +652,7 @@ export class Daemon {
     this.markActivity(); // hosted: work in progress — don't idle-suspend under it
     log(`running routine "${routine.name}"`);
 
-    const config = loadDaemonConfig();
+    const config = loadHarborConfig();
     const modelSpec = routine.model ?? config.defaultModel;
     const split = splitRoutineTools(routine.tools);
     // MCP tools (server__tool) join the allow-list: the mcpAdapter loaded in runSession
@@ -770,7 +770,7 @@ export class Daemon {
       status = "error";
       error = err instanceof Error ? err.message : String(err);
     } finally {
-      // Revoke ONLY this run's account inference session (the daemon's own child API
+      // Revoke ONLY this run's account inference session (the harbor's own child API
       // session — relay/outbox — stays alive until shutdown). Drop Pi's persisted copy
       // too so a later run's fallback never reuses a revoked token. Best-effort.
       if (spawnedAccount) {
@@ -788,7 +788,7 @@ export class Daemon {
   // just executes. Concurrency-guarded by a `task:<title>` key in `this.running` (never
   // collides with routine ids, which are uuids).
   async runTask(spec: TaskSpec): Promise<void> {
-    const config = loadDaemonConfig();
+    const config = loadHarborConfig();
     const cwd = spec.cwd && spec.cwd.trim() ? spec.cwd : process.cwd();
     const modelSpec = spec.model && spec.model.trim() ? spec.model : config.defaultModel;
     const split = spec.tools && spec.tools.length ? splitRoutineTools(spec.tools) : undefined;
@@ -825,7 +825,7 @@ export class Daemon {
     void (async () => {
       try {
         const handle = await createLiveTaskSession(spec, {
-          defaultModel: loadDaemonConfig().defaultModel,
+          defaultModel: loadHarborConfig().defaultModel,
           parseSpec,
           log,
           onClosed: (id) => this.liveTasks.delete(id),
@@ -845,7 +845,7 @@ export class Daemon {
 
   // Run a saved workflow graph to completion (workflows_run / the injected runNow). The
   // signed-frame gate (guardControl, STRICT) already ran before this is reached. Wires the
-  // runner's injected seams to the daemon's real capabilities: agent steps → runSession
+  // runner's injected seams to the harbor's real capabilities: agent steps → runSession
   // (SAFE_TOOLS gate), gates → relay approvals, scripts → a gated child process (only when
   // attended + approved; the runner fail-closes an unattended script itself), and the
   // result is sealed to the outbox + mirrored live, exactly like an ad-hoc task.
@@ -863,9 +863,9 @@ export class Daemon {
         runScript: (step, cwd) => this.runScript(step, cwd),
         askGate: (step, promptText) => this.askGate(step.options.map((o) => ({ name: o.name, description: o.description })), promptText),
         attended: () => this.controllerAttached,
-        // Preserve the daemon's one-at-a-time discipline: fan-out (parallel/for_each) runs
+        // Preserve the harbor's one-at-a-time discipline: fan-out (parallel/for_each) runs
         // sequentially here, so a workflow never spawns concurrent headless sessions on the
-        // resident daemon. (The standalone runner defaults to 4; a UI host can raise it.)
+        // resident harbor. (The standalone runner defaults to 4; a UI host can raise it.)
         concurrency: 1,
         // An effectful step reached while unattended: seal a "needs approval" notice so the
         // user catches up, and (if a controller is somehow attached) surface it live.
@@ -878,7 +878,7 @@ export class Daemon {
         },
         sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
         log: (m) => log(`  [wf ${wf.workflow.name}] ${m}`),
-        // Live progress: announce each step start in the daemon terminal's feed.
+        // Live progress: announce each step start in the harbor terminal's feed.
         onEvent: (ev) => {
           if (ev.type === "step_start") this.relay?.sendNotice(`▶ ${ev.name}`);
         },
@@ -969,7 +969,7 @@ export class Daemon {
   // (so a later step can route on `{{ step.output.field }}`). Non-JSON output leaves
   // `output` empty and lives in `text` — the raw/display path.
   private async runWorkflowAgent(spec: AgentRunSpec): Promise<AgentRunResult> {
-    const config = loadDaemonConfig();
+    const config = loadHarborConfig();
     const model = spec.model && spec.model.trim() ? spec.model : config.defaultModel;
     const split = spec.tools && spec.tools.length ? splitRoutineTools(spec.tools) : undefined;
     const tools = [...(split && split.builtin.length > 0 ? split.builtin : SAFE_TOOLS), ...(split?.mcp ?? [])];
@@ -1031,13 +1031,13 @@ export class Daemon {
   }
 }
 
-// Entry point for `privateer daemon`. Caller must have imported ./boot.ts first.
-export function runDaemon(): void {
-  const daemon = new Daemon();
-  daemon.start();
+// Entry point for `privateer harbor`. Caller must have imported ./boot.ts first.
+export function runHarbor(): void {
+  const harbor = new Harbor();
+  harbor.start();
   const shutdown = () => {
     log("shutting down");
-    daemon.stop();
+    harbor.stop();
     void revokeLocalSessions().finally(() => process.exit(0));
   };
   process.on("SIGINT", shutdown);

package/src/{daemon → harbor}/ipc.ts

@@ -4,12 +4,12 @@ import { join } from "node:path";
 import { globalDir } from "../config/paths.ts";
 import type { Routine } from "../routines/schema.ts";
 
-// The CLI/TUI talks to the resident daemon over a unix domain socket. The protocol
+// The CLI/TUI talks to the resident harbor over a unix domain socket. The protocol
 // is one JSON request per connection, answered with one JSON response, both
 // newline-terminated. Kept tiny and local — nothing crosses the machine boundary.
 
-export function daemonSocketPath(): string {
-  return join(globalDir(), "daemon.sock");
+export function harborSocketPath(): string {
+  return join(globalDir(), "harbor.sock");
 }
 
 export type IpcRequest =
@@ -26,16 +26,16 @@ export interface IpcResponse {
   ok: boolean;
   message?: string;
   routines?: Routine[];
-  // Daemon liveness/uptime for `status`.
+  // Harbor liveness/uptime for `status`.
   pid?: number;
   uptimeSec?: number;
 }
 
 export type IpcHandler = (req: IpcRequest) => Promise<IpcResponse> | IpcResponse;
 
-// Start the daemon-side socket server. Returns the Server so the caller can close it.
+// Start the harbor-side socket server. Returns the Server so the caller can close it.
 export function startIpcServer(handler: IpcHandler): Server {
-  const path = daemonSocketPath();
+  const path = harborSocketPath();
   // A stale socket file from a previous crash would block bind; remove it first.
   if (existsSync(path)) {
     try {
@@ -73,20 +73,20 @@ export function startIpcServer(handler: IpcHandler): Server {
   return server;
 }
 
-// Client side: send one request, resolve with the response. Rejects if the daemon
+// Client side: send one request, resolve with the response. Rejects if the harbor
 // isn't running (no socket / connection refused) so callers can offer to start it.
-export function sendToDaemon(req: IpcRequest, timeoutMs = 5_000): Promise<IpcResponse> {
-  const path = daemonSocketPath();
+export function sendToHarbor(req: IpcRequest, timeoutMs = 5_000): Promise<IpcResponse> {
+  const path = harborSocketPath();
   return new Promise<IpcResponse>((resolve, reject) => {
     if (!existsSync(path)) {
-      reject(new DaemonNotRunningError());
+      reject(new HarborNotRunningError());
       return;
     }
     const sock = createConnection(path);
     let buf = "";
     const timer = setTimeout(() => {
       sock.destroy();
-      reject(new Error("daemon did not respond in time"));
+      reject(new Error("harbor did not respond in time"));
     }, timeoutMs);
     sock.on("connect", () => sock.end(JSON.stringify(req) + "\n"));
     sock.on("data", (chunk) => {
@@ -97,29 +97,29 @@ export function sendToDaemon(req: IpcRequest, timeoutMs = 5_000): Promise<IpcRes
       try {
         resolve(JSON.parse(buf.trim()) as IpcResponse);
       } catch {
-        reject(new Error("malformed response from daemon"));
+        reject(new Error("malformed response from harbor"));
       }
     });
     sock.on("error", (err: NodeJS.ErrnoException) => {
       clearTimeout(timer);
       // ECONNREFUSED means a stale socket file with no listener behind it.
-      if (err.code === "ENOENT" || err.code === "ECONNREFUSED") reject(new DaemonNotRunningError());
+      if (err.code === "ENOENT" || err.code === "ECONNREFUSED") reject(new HarborNotRunningError());
       else reject(err);
     });
   });
 }
 
-export class DaemonNotRunningError extends Error {
+export class HarborNotRunningError extends Error {
   constructor() {
-    super("Privateer daemon is not running. Start it with `privateer daemon`.");
-    this.name = "DaemonNotRunningError";
+    super("Harbor is not running. Start it with `privateer harbor`.");
+    this.name = "HarborNotRunningError";
   }
 }
 
-// Convenience: is the daemon reachable right now?
-export async function daemonIsRunning(): Promise<boolean> {
+// Convenience: is the harbor reachable right now?
+export async function harborIsRunning(): Promise<boolean> {
   try {
-    const res = await sendToDaemon({ cmd: "status" }, 2_000);
+    const res = await sendToHarbor({ cmd: "status" }, 2_000);
     return res.ok;
   } catch {
     return false;

package/src/{daemon → harbor}/service.ts

@@ -1,28 +1,35 @@
-// Install the resident daemon as a per-user OS service so it auto-starts at login
+// Install the resident harbor as a per-user OS service so it auto-starts at login
 // and survives the terminal closing — the difference between "the CLI is running"
-// and "the daemon is reachable from the app even when no CLI is". macOS → launchd
+// and "the harbor is reachable from the app even when no CLI is". macOS → launchd
 // user agent; Linux → systemd --user unit. No root: everything lives under the
 // user's own home and login session.
 //
 // ORDERING NOTE: this module is import-safe (node builtins + our paths only, no Pi),
-// so the daemon CLI can load it without going through boot.ts.
+// so the harbor CLI can load it without going through boot.ts.
 import { existsSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { homedir } from "node:os";
 import { join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { globalDir } from "../config/paths.ts";
-import { daemonIsRunning } from "./ipc.ts";
+import { harborIsRunning } from "./ipc.ts";
 
-const LABEL = "pro.privateer.daemon"; // launchd label / reverse-dns id
-const UNIT = "privateer-daemon.service"; // systemd --user unit name
+const LABEL = "pro.privateer.harbor"; // launchd label / reverse-dns id
+const UNIT = "privateer-harbor.service"; // systemd --user unit name
 
-// Absolute path to the node launcher that boots + runs the daemon (bin/privateer-daemon.mjs).
+// Pre-rename service identity ("daemon"). Kept ONLY so install/uninstall can evict a
+// service a user installed before the harbor rename — otherwise it lingers as an
+// orphaned launchd agent / systemd unit still running the old launcher. Never written,
+// only torn down.
+const OLD_LABEL = "pro.privateer.daemon";
+const OLD_UNIT = "privateer-daemon.service";
+
+// Absolute path to the node launcher that boots + runs the harbor (bin/privateer-harbor.mjs).
 // Resolved from THIS module so it's correct for both a dev checkout and a global npm
-// install (…/node_modules/privateer-agent/bin/privateer-daemon.mjs).
-function daemonLauncherPath(): string {
-  const here = dirname(fileURLToPath(import.meta.url)); // …/src/daemon
-  return resolve(here, "../../bin/privateer-daemon.mjs");
+// install (…/node_modules/privateer-agent/bin/privateer-harbor.mjs).
+function harborLauncherPath(): string {
+  const here = dirname(fileURLToPath(import.meta.url)); // …/src/harbor
+  return resolve(here, "../../bin/privateer-harbor.mjs");
 }
 
 // The node binary to bake into the unit. We use the CURRENT interpreter (>=22, the
@@ -32,12 +39,12 @@ function nodeBinaryPath(): string {
   return process.execPath;
 }
 
-function daemonLogPath(): string {
-  return join(globalDir(), "daemon.log");
+function harborLogPath(): string {
+  return join(globalDir(), "harbor.log");
 }
 
 // Env we forward into the service so a non-default home / server URL survives. Kept
-// tiny and explicit — the daemon reads the rest from ~/.privateer.
+// tiny and explicit — the harbor reads the rest from ~/.privateer.
 function forwardedEnv(): Record<string, string> {
   const env: Record<string, string> = {};
   if (process.env.PRIVATEER_HOME) env.PRIVATEER_HOME = process.env.PRIVATEER_HOME;
@@ -56,13 +63,13 @@ function xmlEscape(s: string): string {
 }
 
 function launchdPlist(): string {
-  const args = [nodeBinaryPath(), daemonLauncherPath(), "run"];
+  const args = [nodeBinaryPath(), harborLauncherPath(), "run"];
   const envVars = forwardedEnv();
   const argXml = args.map((a) => `    <string>${xmlEscape(a)}</string>`).join("\n");
   const envXml = Object.entries(envVars)
     .map(([k, v]) => `    <key>${xmlEscape(k)}</key>\n    <string>${xmlEscape(v)}</string>`)
     .join("\n");
-  const log = xmlEscape(daemonLogPath());
+  const log = xmlEscape(harborLogPath());
   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">
@@ -86,7 +93,18 @@ ${envVars.PRIVATEER_HOME || envVars.PRIVATEER_SERVER_URL ? `  <key>EnvironmentVa
 `;
 }
 
+// Evict a pre-rename launchd agent (pro.privateer.daemon) if one is installed, so the
+// harbor rename doesn't leave the old service running the old launcher alongside it.
+function evictOldLaunchd(): void {
+  const oldPlist = join(homedir(), "Library", "LaunchAgents", `${OLD_LABEL}.plist`);
+  if (existsSync(oldPlist)) {
+    spawnSync("launchctl", ["unload", "-w", oldPlist], { stdio: "ignore" });
+    rmSync(oldPlist, { force: true });
+  }
+}
+
 function installLaunchd(): void {
+  evictOldLaunchd();
   const plist = launchAgentPath();
   mkdirSync(dirname(plist), { recursive: true });
   writeFileSync(plist, launchdPlist());
@@ -100,6 +118,7 @@ function installLaunchd(): void {
 }
 
 function uninstallLaunchd(): void {
+  evictOldLaunchd();
   const plist = launchAgentPath();
   if (existsSync(plist)) {
     spawnSync("launchctl", ["unload", "-w", plist], { stdio: "ignore" });
@@ -115,12 +134,12 @@ function systemdUnitPath(): string {
 }
 
 function systemdUnit(): string {
-  const exec = [nodeBinaryPath(), daemonLauncherPath(), "run"].map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ");
+  const exec = [nodeBinaryPath(), harborLauncherPath(), "run"].map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ");
   const envLines = Object.entries(forwardedEnv())
     .map(([k, v]) => `Environment=${k}=${v}`)
     .join("\n");
   return `[Unit]
-Description=Privateer resident agent daemon (routines + app-driven task spawns)
+Description=Privateer resident agent harbor (routines + app-driven task spawns)
 After=network-online.target
 Wants=network-online.target
 
@@ -136,7 +155,20 @@ WantedBy=default.target
 `;
 }
 
+// Evict a pre-rename systemd --user unit (privateer-daemon.service) if present, so the
+// harbor rename doesn't leave the old unit enabled alongside the new one.
+function evictOldSystemd(): void {
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  const oldUnit = join(base, "systemd", "user", OLD_UNIT);
+  if (existsSync(oldUnit)) {
+    spawnSync("systemctl", ["--user", "disable", "--now", OLD_UNIT], { stdio: "ignore" });
+    rmSync(oldUnit, { force: true });
+    spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+  }
+}
+
 function installSystemd(): void {
+  evictOldSystemd();
   const unit = systemdUnitPath();
   mkdirSync(dirname(unit), { recursive: true });
   writeFileSync(unit, systemdUnit());
@@ -152,6 +184,7 @@ function installSystemd(): void {
 }
 
 function uninstallSystemd(): void {
+  evictOldSystemd();
   const unit = systemdUnitPath();
   spawnSync("systemctl", ["--user", "disable", "--now", UNIT], { stdio: "ignore" });
   if (existsSync(unit)) rmSync(unit, { force: true });
@@ -182,7 +215,7 @@ export function serviceInfo(): ServiceInfo {
     supported: platform === "darwin" || platform === "linux",
     installed: !!unitPath && existsSync(unitPath),
     unitPath,
-    logPath: daemonLogPath(),
+    logPath: harborLogPath(),
   };
 }
 
@@ -191,7 +224,7 @@ export function installService(): ServiceInfo {
   const platform = process.platform;
   if (platform === "darwin") installLaunchd();
   else if (platform === "linux") installSystemd();
-  else throw new Error(`Auto-start isn't supported on ${platform}. Run \`privateer daemon\` yourself, or keep a terminal open.`);
+  else throw new Error(`Auto-start isn't supported on ${platform}. Run \`privateer harbor\` yourself, or keep a terminal open.`);
   return serviceInfo();
 }
 
@@ -203,15 +236,15 @@ export function uninstallService(): ServiceInfo {
   return serviceInfo();
 }
 
-// Human-readable status line for `privateer daemon status`: whether the service is
-// installed AND whether a daemon is actually answering on the IPC socket right now.
+// Human-readable status line for `privateer harbor status`: whether the service is
+// installed AND whether a harbor is actually answering on the IPC socket right now.
 export async function statusReport(): Promise<string> {
   const info = serviceInfo();
-  const live = await daemonIsRunning();
+  const live = await harborIsRunning();
   const lines = [
-    `platform:  ${info.platform}${info.supported ? "" : " (auto-start unsupported — run `privateer daemon` manually)"}`,
+    `platform:  ${info.platform}${info.supported ? "" : " (auto-start unsupported — run `privateer harbor` manually)"}`,
     `service:   ${info.installed ? `installed (${info.unitPath})` : "not installed"}`,
-    `daemon:    ${live ? "running (answering IPC)" : "not reachable"}`,
+    `harbor:    ${live ? "running (answering IPC)" : "not reachable"}`,
     `logs:      ${info.logPath}`,
   ];
   // Surface a stale-unit hint: file present but nothing answering usually means it
@@ -220,11 +253,11 @@ export async function statusReport(): Promise<string> {
   return lines.join("\n");
 }
 
-// Best-effort read of the tail of the daemon log (for a `status --log` affordance or
+// Best-effort read of the tail of the harbor log (for a `status --log` affordance or
 // error surfacing). Returns "" if absent.
-export function tailDaemonLog(maxBytes = 4_000): string {
+export function tailHarborLog(maxBytes = 4_000): string {
   try {
-    const buf = readFileSync(daemonLogPath(), "utf8");
+    const buf = readFileSync(harborLogPath(), "utf8");
     return buf.length > maxBytes ? buf.slice(buf.length - maxBytes) : buf;
   } catch {
     return "";

package/src/main.ts

@@ -4,7 +4,7 @@
 //
 // Phase 1 skeleton: this prints the resolved boot state so `npm start` proves
 // the boot chain end-to-end (env pinned, dispatcher installed) without a TUI.
-// Phases 4/6 replace the body with the daemon/relay wiring and the pi-tui app.
+// Phases 4/6 replace the body with the harbor/relay wiring and the pi-tui app.
 
 import "./boot.ts";
 

package/src/providers/account.ts

@@ -322,7 +322,7 @@ export function makeAccountProvider() {
     // auth.json entry (see the LIFECYCLE HAZARD note in src/auth/privateer.ts). So a
     // signed-in user who quits and relaunches lands on privateer/* with no key at
     // all, and the first prompt dead-ends on "No API key found for privateer." — even
-    // though the banner says "connected". The REPL (cli/chat.ts) and the daemon
+    // though the banner says "connected". The REPL (cli/chat.ts) and the harbor
     // already spawn one at startup; this gives the TUI the same seed.
     pi.on?.("session_start", (_e, ctx) => void armAccountCredential(ctx));
   };

package/src/providers/defaultModel.ts

@@ -1,6 +1,6 @@
 // The single source of truth for "which model do we default to?" — shared by every
 // entry point that has to pick a model when the user hasn't named one: the REPL
-// (cli/chat.ts), the daemon (routines), the channels runner, and the login-time hook
+// (cli/chat.ts), the harbor (routines), the channels runner, and the login-time hook
 // that seeds Pi's TUI default (ensurePiDefaultModel).
 //
 // The bug this fixes: each of those sites used to hardcode `openrouter/openai/gpt-4o-

package/src/remote/channelsControl.ts

@@ -3,13 +3,13 @@
  * messaging-channel config (Telegram/Slack/Discord/WhatsApp) rather than scheduled
  * routines.
  *
- * Like routines, this is owned by the ALWAYS-ON daemon relay (daemon/index.ts),
- * NOT the channels daemon (channels/run.ts) — which may be down, and which the app
+ * Like routines, this is owned by the ALWAYS-ON harbor relay (harbor/index.ts),
+ * NOT the channels harbor (channels/run.ts) — which may be down, and which the app
  * must be able to configure before it has ever run. So this control edits the
- * `channels` block of ~/.privateer/config.json; the channels daemon adopts changes
+ * `channels` block of ~/.privateer/config.json; the channels harbor adopts changes
  * on its next RESTART, matching run.ts's deliberate "no in-chat toggle, restart is
  * the fail-safe reset" posture. `running` is a best-effort read of the channels
- * daemon's heartbeat (channels/status.ts), never a dependency.
+ * harbor's heartbeat (channels/status.ts), never a dependency.
  *
  * SECRETS: bot tokens are WRITE-ONLY from the app's perspective. list() NEVER
  * returns a token value — it reports `configured`, `running`, and `secretsSet`
@@ -46,7 +46,7 @@ const SECRET_FIELDS: Record<ChannelPlatform, string[]> = {
 export interface RemoteChannel {
   platform: ChannelPlatform;
   configured: boolean; // a config block exists for this platform
-  running: boolean; // the channels daemon is currently serving it
+  running: boolean; // the channels harbor is currently serving it
   adminCount: number;
   memberCount: number;
   posture: ChannelPosture;
@@ -94,7 +94,7 @@ function cleanStrList(v: unknown): string[] | undefined {
 }
 
 export function makeChannelsControl(opts: {
-  // Which platforms the channels daemon is serving right now (heartbeat read).
+  // Which platforms the channels harbor is serving right now (heartbeat read).
   // Absent → everything reports not-running.
   runningPlatforms?: () => Set<string>;
 }): ChannelsControl {
@@ -173,7 +173,7 @@ export function makeChannelsControl(opts: {
       } catch (e) {
         return { ok: false, message: `Couldn't write config: ${e instanceof Error ? e.message : String(e)}` };
       }
-      return { ok: true, message: `Saved ${draft.platform}. Restart the channels daemon to apply.` };
+      return { ok: true, message: `Saved ${draft.platform}. Restart the channels harbor to apply.` };
     },
 
     remove(platform: ChannelPlatform): { ok: boolean; message?: string } {
@@ -186,7 +186,7 @@ export function makeChannelsControl(opts: {
       } catch (e) {
         return { ok: false, message: `Couldn't write config: ${e instanceof Error ? e.message : String(e)}` };
       }
-      return { ok: true, message: `Removed ${platform}. Restart the channels daemon to apply.` };
+      return { ok: true, message: `Removed ${platform}. Restart the channels harbor to apply.` };
     },
   };
 }

package/src/remote/controlAuth.ts

@@ -9,7 +9,7 @@
 // skill). channels_save has its own bespoke verify (it also carries sealed secrets);
 // everything else routes through here.
 //
-// Both loci call this: the daemon (routines_*/channels_remove, termId = routineRelayId)
+// Both loci call this: the harbor (routines_*/channels_remove, termId = routineRelayId)
 // and each interactive terminal (extensions_*/skills_*, termId = the relay's id).
 //
 // Fail-closed: no pinned account key, a missing signature, a bad signature, or a stale