privateer-agent 0.6.9 → 0.7.0

package/src/remote/liveTaskSession.ts

@@ -1,9 +1,9 @@
-// A live, app-drivable agent session spawned on demand by the daemon (task_spawn,
-// mode:"live"). Unlike a headless task (daemon/index.ts runTask → restricted tools +
+// A live, app-drivable agent session spawned on demand by the harbor (task_spawn,
+// mode:"live"). Unlike a headless task (harbor/index.ts runTask → restricted tools +
 // bypass gate + outbox), this stands up a FULL interactive session behind its own relay
 // terminal so the app can attach and drive it in real time: stream tokens, approve each
 // tool, interrupt. It is the same wiring cli/chat.ts uses for `/remote-access`, factored
-// so the daemon can create one without a TTY.
+// so the harbor can create one without a TTY.
 //
 // SAFETY: the gate runs in "default" mode, so on a driven turn every gated tool relays to
 // the app for allow/deny (bridge.remoteAsk) and fail-closes if the controller is gone —
@@ -70,7 +70,7 @@ export async function createLiveTaskSession(spec: TaskSpec, deps: LiveTaskDeps):
     if (lifeTimer) clearTimeout(lifeTimer);
     try { relay?.stop(); } catch { /* already stopped */ }
     // Revoke ONLY this session's account inference session so it doesn't linger in the
-    // app's Linked Devices; the daemon's own child session stays alive. Best-effort.
+    // app's Linked Devices; the harbor's own child session stays alive. Best-effort.
     if (spawnedAccount) {
       try { await revokeAccountSession(); } catch { /* server TTL is the fallback */ }
       try { servicesRef?.authStorage?.remove?.("privateer"); } catch { /* nothing persisted */ }

package/src/remote/mcpControl.ts

@@ -2,7 +2,7 @@
  * MCP connector management for the app — the sibling of channelsControl.ts, but for
  * MCP server config rather than messaging channels. It is what lets the phone/web
  * client add, toggle, and remove MCP connectors on a Node HOST it drives over the
- * relay (the daemon today; an interactive terminal by the same shape).
+ * relay (the harbor today; an interactive terminal by the same shape).
  *
  * The client itself can NEVER run MCP — a browser tab / RN runtime can't spawn a
  * stdio child or hold the adapter. So "serving MCP to phone/web" means MANAGING the
@@ -20,7 +20,7 @@
  * returns an env VALUE — only which env keys exist (`envKeys`) and which are non-empty
  * (`secretsSet`), by name. save() persists whatever env VALUES it is handed in
  * `draft.env`; the seal/open of those values in transit is the caller's job (the
- * daemon opens a sealed-box addressed to its terminal, mirroring applyChannelSave), so
+ * harbor opens a sealed-box addressed to its terminal, mirroring applyChannelSave), so
  * this module only ever deals in the plaintext files it already owns.
  *
  * Framework-agnostic: nothing here imports React or the relay. The caller owns the

package/src/remote/relayClient.ts

@@ -45,7 +45,7 @@ function tsOf(frame: { ts?: unknown }): number | undefined {
 }
 
 // Parse a task_submit/task_spawn frame into a TaskSpec, keeping ONLY well-typed,
-// present fields (absent → left undefined). The daemon re-derives the canonical signed
+// present fields (absent → left undefined). The harbor re-derives the canonical signed
 // args from this (taskControlArgs, undefined → null), so it must not invent fields.
 export function parseTaskSpec(frame: {
   prompt?: string;
@@ -79,10 +79,10 @@ function safe(s: string, max: number): string {
   return clip(redactSecrets(s), max);
 }
 
-// An ad-hoc task the app asks the daemon to run headlessly (task_submit) or to spawn
+// An ad-hoc task the app asks the harbor to run headlessly (task_submit) or to spawn
 // as a live-drivable session (task_spawn). Only `prompt` is required; the rest fall back
-// to daemon defaults. The SAME field set is what the app canonical-signs into the control
-// envelope (client/services/accountSign.ts) and the daemon re-derives to verify (index.ts
+// to harbor defaults. The SAME field set is what the app canonical-signs into the control
+// envelope (client/services/accountSign.ts) and the harbor re-derives to verify (index.ts
 // taskControlArgs) — keep the two in sync, byte for byte, like the other signed frames.
 export interface TaskSpec {
   prompt: string;
@@ -99,7 +99,7 @@ export interface RelayCallbacks {
   onInterrupt: () => void;
   // The app asked to turn remote access OFF entirely (the in-app "End remote
   // access" action). The owner should disable /remote-access — i.e. stop this
-  // client and not reconnect. Optional: the routines daemon handles it too, but
+  // client and not reconnect. Optional: the routines harbor handles it too, but
   // callbacks that predate it keep compiling.
   onTerminate?: () => void;
   // The account signed this terminal out server-side (revoked from the app's
@@ -127,6 +127,10 @@ export interface RelayCallbacks {
   // The app answered a CLI-initiated text-input prompt (the id from requestInput).
   // A null value means the app dismissed the prompt without submitting.
   onInputResponse?: (id: string, value: string | null) => void;
+  // The app's composer is autocompleting an `@file` mention — reply with the cwd
+  // files/dirs matching `query` (a sendFileMatches frame, keyed by the same id).
+  // Read-only; resolution of the picked path still happens on the prompt turn.
+  onFilesSearch?: (id: string, query: string) => void;
   // The app opened the extensions manager — reply with the current installed list
   // (a sendExtensions frame). Optional so pre-extensions callbacks keep compiling.
   onExtensionsList?: () => void;
@@ -147,10 +151,10 @@ export interface RelayCallbacks {
   // The app toggled a user skill's model-invocation availability.
   onSkillSetEnabled?: (name: string, enabled: boolean, sig?: string, ts?: number) => void;
   // The app opened the routines manager — reply with the current routines list
-  // (a sendRoutines frame). Owned by the daemon, so these only fire on its relay.
+  // (a sendRoutines frame). Owned by the harbor, so these only fire on its relay.
   onRoutinesList?: () => void;
   // The app asked to create (no id) or edit (id) a routine. The raw draft object is
-  // handed through untyped; the daemon's routinesControl validates it. Signed (H2) —
+  // handed through untyped; the harbor's routinesControl validates it. Signed (H2) —
   // a forged routine runs a headless bypass-mode session (RCE), so it MUST be verified.
   onRoutinesSave?: (draft: Record<string, unknown>, sig?: string, ts?: number) => void;
   // The app asked to delete a routine by id or name.
@@ -163,14 +167,14 @@ export interface RelayCallbacks {
   // right now — a fresh restricted-tool bypass session whose result is sealed to the
   // account outbox. Signed (H2) — a forged task_submit runs an arbitrary headless
   // session (RCE), identical in blast radius to a forged routines_run, so it MUST be
-  // verified via controlAuth before it runs. Daemon-owned (fires only on its relay).
+  // verified via controlAuth before it runs. Harbor-owned (fires only on its relay).
   onTaskSubmit?: (spec: TaskSpec, sig?: string, ts?: number) => void;
   // The app asked to SPAWN a fresh interactive session it can drive live (mode:"live").
-  // The daemon stands up a new RemoteBridge terminal and replies (sendTaskSpawned) with
+  // The harbor stands up a new RemoteBridge terminal and replies (sendTaskSpawned) with
   // its termId so the app can attach. Same signed-RCE gate as task_submit.
   onTaskSpawn?: (spec: TaskSpec, sig?: string, ts?: number) => void;
   // The app opened the channels manager — reply with the current channel config
-  // (a sendChannels frame). Owned by the daemon, so these only fire on its relay.
+  // (a sendChannels frame). Owned by the harbor, so these only fire on its relay.
   onChannelsList?: () => void;
   // The app asked to create/edit a platform's channel config. `draft` carries only
   // NON-secret fields (roles/posture/tools/model). `sealedSecrets`, when present, is
@@ -183,7 +187,7 @@ export interface RelayCallbacks {
   // (H2) — a forged removal is a DoS (the bot stops until re-added).
   onChannelsRemove?: (platform: string, sig?: string, ts?: number) => void;
   // The app opened the MCP connectors manager — reply with the current MCP config
-  // (a sendMcp frame). Owned by the daemon (the host that runs the adapter), so these
+  // (a sendMcp frame). Owned by the harbor (the host that runs the adapter), so these
   // only fire on its relay. Read-only, so unsigned.
   onMcpList?: () => void;
   // The app asked to create/edit an MCP connector. `draft` carries only NON-secret
@@ -199,12 +203,12 @@ export interface RelayCallbacks {
   // The app asked to delete a connector by name. Signed (H2) — a forged removal is a DoS.
   onMcpRemove?: (name: string, sig?: string, ts?: number) => void;
   // The app opened the workflows manager — reply with the current workflow summaries
-  // (a sendWorkflows frame). Owned by the daemon, so these only fire on its relay.
+  // (a sendWorkflows frame). Owned by the harbor, so these only fire on its relay.
   onWorkflowsList?: () => void;
   // The app opened one workflow in its editor — reply with the full graph (sendWorkflow).
   onWorkflowsGet?: (idOrName: string) => void;
   // The app asked to create (no workflow.id) or edit (id) a workflow. The raw graph is
-  // handed through untyped; the daemon's workflowsControl strict-validates it. Signed
+  // handed through untyped; the harbor's workflowsControl strict-validates it. Signed
   // (H2) — a forged save plants a `script` step that BYPASSES the permission gate (RCE),
   // exactly like a forged routine, so it MUST be verified before it persists.
   onWorkflowsSave?: (draft: Record<string, unknown>, sig?: string, ts?: number) => void;
@@ -286,7 +290,7 @@ export class RelayClient {
   private buf = "";
   private flushTimer: ReturnType<typeof setTimeout> | undefined;
   // Stable for this process so reconnects keep the same terminal identity. Callers
-  // may pass a persisted id/label (e.g. the routines daemon, so it shows up as one
+  // may pass a persisted id/label (e.g. the routines harbor, so it shows up as one
   // recognizable "Privateer Routines" terminal across restarts instead of a fresh
   // random one each time).
   private readonly termId: string;
@@ -424,6 +428,7 @@ export class RelayClient {
       title?: string;
       tools?: unknown;
       mode?: string;
+      query?: string;
       sig?: string;
       ts?: number;
     };
@@ -467,6 +472,9 @@ export class RelayClient {
       case "input_response":
         if (frame.id) this.cb.onInputResponse?.(frame.id, typeof frame.value === "string" ? frame.value : null);
         break;
+      case "files_search":
+        if (typeof frame.id === "string") this.cb.onFilesSearch?.(frame.id, typeof frame.query === "string" ? frame.query : "");
+        break;
       case "extensions_list":
         this.cb.onExtensionsList?.();
         break;
@@ -540,7 +548,7 @@ export class RelayClient {
         break;
       case "mcp_save":
         // The connector rides in `draft` (same slot as channels_save), untyped — the
-        // daemon strict-validates it via mcpControl.save after the signature check.
+        // harbor strict-validates it via mcpControl.save after the signature check.
         if (frame.draft && typeof frame.draft === "object") {
           this.cb.onMcpSave?.(
             frame.draft,
@@ -563,7 +571,7 @@ export class RelayClient {
         if (typeof frame.idOrName === "string") this.cb.onWorkflowsGet?.(frame.idOrName);
         break;
       case "workflows_save":
-        // The graph rides in `draft` (same slot as channels_save), untyped — the daemon
+        // The graph rides in `draft` (same slot as channels_save), untyped — the harbor
         // strict-validates it via workflowsControl.save after the signature check.
         if (frame.draft && typeof frame.draft === "object") this.cb.onWorkflowsSave?.(frame.draft, sig(frame), tsOf(frame));
         break;
@@ -667,7 +675,7 @@ export class RelayClient {
   }
 
   // Push a workflow's live step text / final result to any attached controller as a text
-  // event, so it renders in the daemon terminal's feed. Same durable-copy caveat as
+  // event, so it renders in the harbor terminal's feed. Same durable-copy caveat as
   // sendRoutineResult (the outbox is the source of truth).
   sendWorkflowResult(name: string, content: string): boolean {
     if (!this.isConnected()) return false;
@@ -678,7 +686,7 @@ export class RelayClient {
 
   // Tell the app that a live task session was stood up on `termId` (label for display),
   // so it can open a controller connection to that terminal and drive it. Fire-and-forget
-  // over the daemon's management relay.
+  // over the harbor's management relay.
   sendTaskSpawned(termId: string, label: string): void {
     this.rawSend({ type: "task_spawned", termId, label });
   }
@@ -771,6 +779,18 @@ export class RelayClient {
     });
   }
 
+  // Reply to an `@file` autocomplete query with the matching cwd files/dirs. Keyed by
+  // the query's id so the app can match it to the in-flight request. Bounded; paths are
+  // cwd-relative (the caller — searchFiles — never emits a path outside the cwd subtree,
+  // so no machine location leaks beyond the project filenames the driver is browsing).
+  sendFileMatches(id: string, matches: { path: string; isDir: boolean }[]): void {
+    this.rawSend({
+      type: "file_matches",
+      id,
+      matches: matches.slice(0, 50).map((m) => ({ path: safe(m.path, 300), isDir: !!m.isDir })),
+    });
+  }
+
   // Push the terminal's installed Pi extensions (the user's own packages; the moat
   // is excluded upstream) to the app's extensions manager. Sent on request and after
   // each add/remove. `busy` drives a progress indicator; `needsRestart` tells the app
@@ -823,7 +843,7 @@ export class RelayClient {
     });
   }
 
-  // Push the daemon's saved routines to the app's routines manager. Sent on request
+  // Push the harbor's saved routines to the app's routines manager. Sent on request
   // and after each save/delete/pause/run. `busy` drives a progress indicator;
   // `message` carries a one-line result/error. Unlike the feed/webhook paths this is
   // the user's OWN config echoed back to their OWN app, so fields are size-clipped
@@ -873,7 +893,7 @@ export class RelayClient {
     });
   }
 
-  // Push the daemon's channel config to the app's channels manager. Sent on request
+  // Push the harbor's channel config to the app's channels manager. Sent on request
   // and after each save/remove. Like sendRoutines this is the user's OWN config
   // echoed to their OWN app — but a bot token NEVER crosses this wire: only
   // `secretsSet` (which secret fields are present, by NAME) is sent, so a relay /
@@ -953,7 +973,7 @@ export class RelayClient {
     });
   }
 
-  // Push the daemon's saved workflows to the app's workflows manager as SUMMARIES (not
+  // Push the harbor's saved workflows to the app's workflows manager as SUMMARIES (not
   // the full graphs — the editor fetches one at a time via sendWorkflow). Sent on request
   // and after each save/remove/run. The user's OWN config echoed to their OWN app, so
   // fields are clipped (not redacted). List bounded like the other managers.

package/src/remote/remoteBridge.ts

@@ -27,6 +27,7 @@ export interface RelayLike {
   sendCommands(commands: { name: string; description?: string }[]): void;
   requestSelect(id: string, req: SelectRequest): void;
   requestInput(id: string, req: InputRequest): void;
+  sendFileMatches(id: string, matches: { path: string; isDir: boolean }[]): void;
   sendExtensions(payload: ExtensionsPayload): void;
   sendSkills(payload: SkillsPayload): void;
 }
@@ -93,6 +94,9 @@ export interface RemoteBridgeConfig {
   onSkillCreate?: (skill: { name: string; description: string; instructions: string }, sig?: string, ts?: number) => void;
   onSkillDelete?: (name: string, sig?: string, ts?: number) => void;
   onSkillSetEnabled?: (name: string, enabled: boolean, sig?: string, ts?: number) => void;
+  // The app is autocompleting an `@file` mention in its composer — the owner should
+  // list the cwd files matching `query` and reply via sendFileMatches(id, …).
+  onFilesSearch?: (id: string, query: string) => void;
   // A controller (re)attached — the owner should push a transcript snapshot.
   onControllerAttached?: () => void;
   onStatus?: (text: string) => void;
@@ -139,7 +143,7 @@ export class RemoteBridge {
     onSkillCreate: (skill, sig, ts) => this.cfg.onSkillCreate?.(skill, sig, ts),
     onSkillDelete: (name, sig, ts) => this.cfg.onSkillDelete?.(name, sig, ts),
     onSkillSetEnabled: (name, enabled, sig, ts) => this.cfg.onSkillSetEnabled?.(name, enabled, sig, ts),
-    // Routines are owned by the daemon, not an interactive session, so its own relay
+    // Routines are owned by the harbor, not an interactive session, so its own relay
     // (not this bridge) handles routines_*. These no-ops just satisfy Required — an
     // interactive terminal never surfaces the routines manager in the app.
     onRoutinesList: () => {},
@@ -147,25 +151,25 @@ export class RemoteBridge {
     onRoutinesDelete: () => {},
     onRoutinesSetEnabled: () => {},
     onRoutinesRun: () => {},
-    // Ad-hoc task spawns are daemon-owned too (they run on / are stood up by the daemon,
+    // Ad-hoc task spawns are harbor-owned too (they run on / are stood up by the harbor,
     // not an interactive session), so its own relay handles task_submit/task_spawn. These
     // no-ops just satisfy Required — an interactive terminal never receives them.
     onTaskSubmit: () => {},
     onTaskSpawn: () => {},
-    // Channels, like routines, are owned by the daemon (its channels/run.ts config),
-    // not an interactive session — the daemon's own relay handles channels_*. These
+    // Channels, like routines, are owned by the harbor (its channels/run.ts config),
+    // not an interactive session — the harbor's own relay handles channels_*. These
     // no-ops just satisfy Required; an interactive terminal never surfaces channels.
     onChannelsList: () => {},
     onChannelsSave: () => {},
     onChannelsRemove: () => {},
-    // MCP connectors, like channels, are managed on the daemon (the host that runs the
-    // adapter) — the daemon's own relay handles mcp_*. These no-ops just satisfy Required;
+    // MCP connectors, like channels, are managed on the harbor (the host that runs the
+    // adapter) — the harbor's own relay handles mcp_*. These no-ops just satisfy Required;
     // an interactive terminal manages MCP over IPC (desktop), never over this relay.
     onMcpList: () => {},
     onMcpSave: () => {},
     onMcpSetEnabled: () => {},
     onMcpRemove: () => {},
-    // Workflows, like routines/channels, are daemon-owned — the daemon's own relay handles
+    // Workflows, like routines/channels, are harbor-owned — the harbor's own relay handles
     // workflows_*. These no-ops just satisfy Required; an interactive terminal never
     // surfaces workflows.
     onWorkflowsList: () => {},
@@ -185,6 +189,7 @@ export class RemoteBridge {
       const resolve = this.pendingInputs.get(id);
       if (resolve) resolve(value);
     },
+    onFilesSearch: (id, query) => this.cfg.onFilesSearch?.(id, query),
     onNoQuarter: (on) => {
       this.noQuarter = on;
       this.relay?.sendNoQuarter(on); // echo the ack back so the app's toggle syncs
@@ -239,6 +244,11 @@ export class RemoteBridge {
     this.relay?.sendCommands(commands);
   }
 
+  // Reply to an app `@file` autocomplete query with the matching cwd entries.
+  sendFileMatches(id: string, matches: { path: string; isDir: boolean }[]): void {
+    this.relay?.sendFileMatches(id, matches);
+  }
+
   // Push the installed-extensions snapshot to the app's extensions manager.
   sendExtensions(payload: ExtensionsPayload): void {
     this.relay?.sendExtensions(payload);

package/src/remote/routinesControl.ts

@@ -2,15 +2,15 @@
  * Routine management for the app.
  *
  * A UI-agnostic wrapper over the routines store so the app (over the relay) can
- * see the daemon's saved routines and create / edit / delete / pause / run them —
+ * see the harbor's saved routines and create / edit / delete / pause / run them —
  * the sibling of extensionsControl.ts and skillsControl.ts, but for scheduled
  * tasks rather than Pi packages/skills.
  *
- * Unlike those two, routines are owned by the DAEMON (not an interactive Pi
+ * Unlike those two, routines are owned by the HARBOR (not an interactive Pi
  * session): they live in routines.json (see routines/store.ts) and fire from the
- * resident scheduler. So this control is wired into the daemon's own relay
+ * resident scheduler. So this control is wired into the harbor's own relay
  * connection (the "Privateer Routines" terminal), not the REPL/TUI. Running a
- * routine now is the one action that needs the daemon itself, so it's injected as
+ * routine now is the one action that needs the harbor itself, so it's injected as
  * `runNow` rather than reaching back into the store.
  *
  * Framework-agnostic: nothing here imports React or the relay. The caller owns the
@@ -75,7 +75,7 @@ export interface RoutinesControl {
   remove(idOrName: string): { ok: boolean; message?: string };
   // Pause/resume a routine. Resuming reschedules nextRun; pausing clears it.
   setEnabled(idOrName: string, enabled: boolean): { ok: boolean; message?: string };
-  // Run a routine now (fire-and-forget on the daemon). ok:false when not found.
+  // Run a routine now (fire-and-forget on the harbor). ok:false when not found.
   run(idOrName: string): { ok: boolean; message?: string };
 }
 
@@ -122,11 +122,11 @@ function toRemote(r: Routine): RemoteRoutine {
 }
 
 export function makeRoutinesControl(opts: {
-  // Working directory for a new routine when the draft omits `cwd` (the daemon's).
+  // Working directory for a new routine when the draft omits `cwd` (the harbor's).
   defaultCwd: () => string;
   // Is a webhook name declared in config? Guards "webhook:<name>" delivery entries.
   webhookExists?: (name: string) => boolean;
-  // Fire a routine now — injected by the daemon (its runRoutine). Absent → run is
+  // Fire a routine now — injected by the harbor (its runRoutine). Absent → run is
   // reported unavailable rather than silently dropped.
   runNow?: (routine: Routine) => void;
 }): RoutinesControl {

package/src/remote/workflowsControl.ts

@@ -3,12 +3,12 @@
  *
  * The sibling of routinesControl.ts / channelsControl.ts, for declarative workflow
  * graphs. UI-agnostic: nothing here imports React or the relay — the caller (the
- * daemon) owns the frame plumbing, the signed-frame gate (authorizeControl), and the
- * run seam. Like routines, workflows are owned by the DAEMON (they run on its resident
- * scheduler / on-demand), so this control is wired into the daemon's own relay.
+ * harbor) owns the frame plumbing, the signed-frame gate (authorizeControl), and the
+ * run seam. Like routines, workflows are owned by the HARBOR (they run on its resident
+ * scheduler / on-demand), so this control is wired into the harbor's own relay.
  *
  * A workflow file is an EXECUTABLE artifact (it can carry `script` steps), so the
- * daemon MUST verify the account signature on every mutating frame (workflows_save /
+ * harbor MUST verify the account signature on every mutating frame (workflows_save /
  * remove / run) via guardControl BEFORE calling save/remove/run here — a forged save
  * would plant a script step, a forged run would execute one. `list`/`get` are read-only.
  *
@@ -48,7 +48,7 @@ export interface WorkflowsControl {
   save(draft: unknown): { ok: boolean; message?: string; id?: string };
   // Remove a workflow by id or name. ok:false when nothing matched.
   remove(idOrName: string): { ok: boolean; message?: string };
-  // Run a workflow now (fire-and-forget on the daemon). ok:false when not found or the
+  // Run a workflow now (fire-and-forget on the harbor). ok:false when not found or the
   // runner isn't wired.
   run(idOrName: string): { ok: boolean; message?: string };
 }
@@ -72,7 +72,7 @@ function draftId(draft: unknown): string | undefined {
 }
 
 export function makeWorkflowsControl(opts: {
-  // Fire a workflow now — injected by the daemon (it owns the runner + its seams).
+  // Fire a workflow now — injected by the harbor (it owns the runner + its seams).
   // Absent → run is reported unavailable rather than silently dropped (mirrors routines).
   runNow?: (wf: Workflow) => void;
 }): WorkflowsControl {

package/src/routines/delivery.ts

@@ -2,13 +2,13 @@ import type { Routine } from "./schema.ts";
 import { webhookName } from "./schema.ts";
 import { writeRoutineOutput, addNotice } from "./store.ts";
 
-// A relay pusher, injected by the daemon. Given the finished result it either
+// A relay pusher, injected by the harbor. Given the finished result it either
 // forwards it to an attached controller immediately ("live") or persists it to the
 // pending-relay queue to flush when the app next attaches ("queued"). Either way the
 // result is durably accounted for, so delivery doesn't add a notice backstop for it.
 export type RelayPusher = (routine: Routine, content: string) => "live" | "queued";
 
-// A cloud-outbox pusher, injected by the daemon. Seals the result to the account's
+// A cloud-outbox pusher, injected by the harbor. Seals the result to the account's
 // outbox public key and POSTs the ciphertext to the server (E2EE store-and-forward),
 // or buffers it durably on failure. Returns "sent" when the server accepted it,
 // "queued" when it was persisted for a later flush — either way the result is
@@ -31,7 +31,7 @@ export interface DeliveryContext {
   // Named endpoints for "webhook:<name>" delivery entries; results POST here.
   webhooks?: Record<string, WebhookTarget>;
   // Scrubs secrets from anything leaving the machine. Webhook bodies always pass
-  // through this when provided (the daemon wires in redactText).
+  // through this when provided (the harbor wires in redactText).
   redact?: (text: string) => string;
   // Injectable for tests; defaults to global fetch.
   fetchImpl?: typeof fetch;
@@ -39,7 +39,7 @@ export interface DeliveryContext {
 
 export interface DeliveryReport {
   // Channels that actually delivered (email is handled inside the agent run, so it
-  // never appears here — see the daemon). Failed webhooks show as
+  // never appears here — see the harbor). Failed webhooks show as
   // "webhook:<name>(failed)" and leave a notice so the result isn't silently lost.
   delivered: string[];
   // Absolute path to latest.md when file delivery ran.
@@ -101,7 +101,7 @@ async function postWebhook(
 // result is never silently lost. `webhook:<name>` POSTs the (redacted) result to a
 // named endpoint from config; a failed or unconfigured webhook leaves a notice.
 // `email` is intentionally not handled here: it is fulfilled inside the agent turn
-// (the daemon adds the Gmail tool + an instruction to the prompt) so plaintext
+// (the harbor adds the Gmail tool + an instruction to the prompt) so plaintext
 // egress stays an explicit, gated action.
 export async function deliver(
   routine: Routine,
@@ -127,7 +127,7 @@ export async function deliver(
   }
 
   // Relay: pushed live to an attached controller, or queued to flush when the app
-  // next attaches (the daemon persists that queue, so it's durable either way). Only
+  // next attaches (the harbor persists that queue, so it's durable either way). Only
   // when no pusher is wired at all do we fall back to a notice so it isn't lost.
   if (wants.has("relay")) {
     const pushed = ctx.pushRelay?.(routine, content);

package/src/routines/schema.ts

@@ -27,7 +27,7 @@ export function webhookName(entry: string): string | null {
 }
 
 // A saved, unattended agent task. Persisted in routines.json and executed by the
-// daemon when its trigger comes due. A routine's trigger is EITHER recurring (a
+// harbor when its trigger comes due. A routine's trigger is EITHER recurring (a
 // cron expression) or one-off (`at`, a specific datetime) — exactly one is set.
 export const Routine = z
   .object({
@@ -48,14 +48,14 @@ export const Routine = z
     model: z.string().optional(),
     // Where to deliver the result. Defaults to on-box file output.
     delivery: z.array(DeliveryEntry).default(["file"]),
-    // Optional tool allow-subset. Unset → the safe read/web set (see daemon). Entries
+    // Optional tool allow-subset. Unset → the safe read/web set (see harbor). Entries
     // may be builtin names ("read") or MCP selectors — "<server>__<tool>" exact or
     // "<server>__*" for a whole server (see routines/toolSelect.ts). Selected MCP
     // tools run unattended under the auto-approve gate, so grant the minimum needed.
     tools: z.array(z.string()).optional(),
     // Paused routines stay in the file but never fire.
     enabled: z.boolean().default(true),
-    // Bookkeeping, updated by the daemon after each run.
+    // Bookkeeping, updated by the harbor after each run.
     lastRun: z.string().optional(),
     lastStatus: z.enum(["ok", "error"]).optional(),
     lastError: z.string().optional(),

package/src/routines/store.ts

@@ -20,7 +20,7 @@ function slug(name: string): string {
   return name.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "routine";
 }
 
-// A stable relay terminal id for the daemon, persisted so it reappears as the same
+// A stable relay terminal id for the harbor, persisted so it reappears as the same
 // "Privateer Routines" terminal in the app across restarts (rather than a fresh
 // random terminal each boot). Random on first use so it stays unique per install —
 // the relay routes on this id with no user namespacing, so a shared constant could
@@ -53,7 +53,7 @@ export function loadRoutines(): Routine[] {
   try {
     return RoutineFile.parse(JSON.parse(readFileSync(path, "utf8"))).routines;
   } catch {
-    // A corrupt or hand-edited file shouldn't crash the daemon; treat as empty.
+    // A corrupt or hand-edited file shouldn't crash the harbor; treat as empty.
     return [];
   }
 }
@@ -160,7 +160,7 @@ export function drainNotices(): RoutineNotice[] {
 }
 
 // A relay result produced while no controller was attached, held until the app
-// next connects. Persisted (not just in-memory) so it survives a daemon restart.
+// next connects. Persisted (not just in-memory) so it survives a harbor restart.
 export interface PendingRelay {
   routine: string;
   at: string; // ISO timestamp

package/src/routines/trigger.ts

@@ -16,7 +16,7 @@ export function triggerError(t: Trigger): string | null {
 
 // The fire time to store as `nextRun`. For cron: the next match strictly after
 // `from`. For a one-off: the fixed `at` time as-is (even if already past, so a
-// missed one-off still fires once when the daemon comes back). Null if unparseable.
+// missed one-off still fires once when the harbor comes back). Null if unparseable.
 export function computeNextRun(t: Trigger, from: Date = new Date()): Date | null {
   if (t.cron) return cronNext(t.cron, from);
   if (t.at) {

package/src/tools/routine.ts

@@ -1,6 +1,6 @@
 // The `create_routine` tool — lets the agent turn "summarize the news every morning"
-// or "remind me at 3pm tomorrow" into a saved routine the scheduler daemon runs
-// unattended (see src/daemon). Ported from tree-cli/src/tools/routine.ts, adapted to
+// or "remind me at 3pm tomorrow" into a saved routine the scheduler harbor runs
+// unattended (see src/harbor). Ported from tree-cli/src/tools/routine.ts, adapted to
 // Pi's registerTool (TypeBox schema) with the in-tool ctx.gate.request removed: in
 // the Pi model our permission-gate extension gates the tool_call itself (classify.ts
 // gives it a "Create routine" prompt + flags email/webhook egress).
@@ -11,7 +11,7 @@ import { configPath } from "../config/paths.ts";
 import { newRoutineId, webhookName, type Routine } from "../routines/schema.ts";
 import { triggerError, computeNextRun, describeTrigger } from "../routines/trigger.ts";
 import { upsertRoutine } from "../routines/store.ts";
-import { sendToDaemon, DaemonNotRunningError } from "../daemon/ipc.ts";
+import { sendToHarbor, HarborNotRunningError } from "../harbor/ipc.ts";
 
 const KNOWN_CHANNELS = new Set(["file", "relay", "notice", "cloud", "email"]);
 
@@ -106,20 +106,20 @@ export const routineToolDefinition = {
       nextRun: next?.toISOString(),
     };
 
-    // Hand to the running daemon (it validates + schedules); fall back to writing the
-    // file so the routine persists until the daemon starts.
+    // Hand to the running harbor (it validates + schedules); fall back to writing the
+    // file so the routine persists until the harbor starts.
     try {
-      const res = await sendToDaemon({ cmd: "add", routine });
+      const res = await sendToHarbor({ cmd: "add", routine });
       if (!res.ok) return text(`Error saving routine: ${res.message ?? "unknown"}`);
       return text(
         `Created routine "${name}" (${describeTrigger({ cron, at })}). ` +
           `Next run ${next ? next.toLocaleString() : "unknown"}, delivery: ${chans.join(", ")}.`,
       );
     } catch (e) {
-      if (e instanceof DaemonNotRunningError) {
+      if (e instanceof HarborNotRunningError) {
         upsertRoutine(routine);
         return text(
-          `Saved routine "${name}" (${describeTrigger({ cron, at })}), but the scheduler daemon isn't ` +
+          `Saved routine "${name}" (${describeTrigger({ cron, at })}), but the scheduler harbor isn't ` +
             `running yet, so it won't fire until you start it.`,
         );
       }