@pellux/goodvibes-daemon 1.28.18 → 1.28.20

package/src/daemon/send/command.ts

@@ -1,5 +1,5 @@
 /**
- * command.ts — `goodvibes-daemon send`, the shell's way to put a message on one
+ * command.ts, `goodvibes-daemon send`, the shell's way to put a message on one
  * of the owner's channels.
  *
  * ## Why this exists
@@ -7,7 +7,7 @@
  * Nothing on this machine could send the owner a message from a script. The
  * three binaries exposed no send verb, the daemon's HTTP API answers
  * `401 AUTH_REQUIRED` to the operator token as stored, and driving the agent to
- * do it failed with `Missing Telegram bot token` — because the credential lives
+ * do it failed with `Missing Telegram bot token`, because the credential lives
  * in the DAEMON tier (`~/.goodvibes/daemon/settings.json`) and the agent was
  * reading its own surface silo. So the one process that could always send was
  * the daemon, and only while it was running.
@@ -15,7 +15,7 @@
  * ## Three properties this command is built around
  *
  * 1. **It uses the delivery path, it is not a second sender.** Everything below
- *    ends in `ChannelDeliveryRouter.deliver()` — the same call
+ *    ends in `ChannelDeliveryRouter.deliver()`, the same call
  *    `AutomationDeliveryManager.sendTarget` makes, reaching the same
  *    per-surface strategies in `strategies-core.ts`. Nothing here talks to a
  *    provider API directly.
@@ -26,7 +26,7 @@
  *    was NOT used, deliberately: it returns an empty array when a feature gate
  *    is off and returns failed attempts rather than throwing, so a caller that
  *    did not inspect its result would report success for a message that never
- *    left the machine — the exact false-green this command exists to avoid. The
+ *    left the machine, the exact false-green this command exists to avoid. The
  *    gate check it would have done is done here instead, explicitly, and a gate
  *    that is off produces a refusal naming the settings key rather than silence.
  *
@@ -34,8 +34,8 @@
  *    through `inertBodyFor` for the target surface before it reaches the router,
  *    and there is no flag, env var or code path that skips that. The message
  *    normally comes from the operator's own shell, but the command must not
- *    become the way something else's text — a log line, a captured error, a
- *    remote agent's output piped in — arrives on the owner's phone rendered as
+ *    become the way something else's text, a log line, a captured error, a
+ *    remote agent's output piped in, arrives on the owner's phone rendered as
  *    live markup with a clickable link in it. See inert-text.ts.
  */
 
@@ -51,7 +51,7 @@ import { inertBodyFor } from './inert-text.ts';
 export type SendDeliver = (request: ChannelDeliveryRequest) => Promise<string | undefined>;
 
 export interface SendCommandDeps {
-  /** Built with a `homeDir` so the daemon tier overlays — see channels.ts. */
+  /** Built with a `homeDir` so the daemon tier overlays, see channels.ts. */
   readonly configManager: Pick<ConfigManager, 'get'>;
   readonly deliver: SendDeliver;
   /** Reads the whole of stdin; only called when no message argument was given. */
@@ -93,12 +93,12 @@ const USAGE = [
   '      --list           Show every channel, whether it is on, and where it sends.',
   '  -h, --help           Print this help',
   '',
-  'A channel that is switched off is refused by name and NOTHING is sent — the',
+  'A channel that is switched off is refused by name and NOTHING is sent: the',
   'command never quietly falls back to the default, so a message meant for a',
   'quiet channel cannot end up on a noisy one.',
   '',
   'The message is always delivered as literal text: markup a channel would',
-  'otherwise render — a Discord masked link, a Slack mention — arrives inert.',
+  'otherwise render (a Discord masked link, a Slack mention) arrives inert.',
 ].join('\n');
 
 function parseSendArgs(argv: readonly string[]): ParsedSendArgs {
@@ -153,7 +153,7 @@ function describeConfiguredChannels(config: Pick<ConfigManager, 'get'>): string
     .map((entry) => entry.channel.id);
   return usable.length > 0
     ? `Configured and ready: ${usable.join(', ')}.`
-    : 'No channel is currently both switched on and given a destination — run: goodvibes-daemon send --list';
+    : 'No channel is currently both switched on and given a destination; run: goodvibes-daemon send --list';
 }
 
 function renderChannelList(config: Pick<ConfigManager, 'get'>): string[] {
@@ -304,7 +304,7 @@ export async function runSendCommand(
   };
 
   const preamble = usedDefault
-    ? [`No channel named — using ${channel.id}: ${defaultReason}.`]
+    ? [`No channel named; using ${channel.id}: ${defaultReason}.`]
     : [];
   try {
     const responseId = await deps.deliver(request);

package/src/daemon/send/composition.ts

@@ -1,5 +1,5 @@
 /**
- * composition.ts — the smallest set of services that can put a message on a
+ * composition.ts, the smallest set of services that can put a message on a
  * channel, built from the daemon's own tier.
  *
  * ## Why not `createRuntimeServices`
@@ -7,7 +7,7 @@
  * The daemon's full runtime graph starts a LAN scan, a cluster coordinator, an
  * inbox poller, a fleet tick, a memory governor and a config watch. Composing
  * it to send one message would build a second, competing set of that state on a
- * machine that is already running a daemon — the same reason `cluster …` is
+ * machine that is already running a daemon, the same reason `cluster …` is
  * intercepted before any runtime is constructed (see src/daemon/cli.ts). This
  * builds only the five objects `ChannelDeliveryRouter` needs and starts no
  * timers, binds no sockets and joins no election, so it is safe to run beside a
@@ -18,7 +18,7 @@
  * That was tried before this command existed: the control-plane API answers
  * `401 AUTH_REQUIRED` to the operator token as stored on disk. More importantly
  * an HTTP-backed send would only work while a daemon is up, and the case this
- * command is for — telling the owner that something has stopped — is exactly
+ * command is for, telling the owner that something has stopped, is exactly
  * when it may not be.
  *
  * ## Where the credentials come from
@@ -34,7 +34,7 @@
 
 import { ChannelDeliveryRouter } from '@pellux/goodvibes-sdk/platform/channels';
 import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
-import { ConfigManager, ServiceRegistry, SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
+import { ConfigManager, ServiceRegistry, SubscriptionManager, sharedSubscriptionsPath } from '@pellux/goodvibes-sdk/platform/config';
 import { createShellPathService } from '@/runtime/index.ts';
 import { SecretsManager } from '../../config/secrets.ts';
 import type { SendDeliver } from './command.ts';
@@ -42,7 +42,7 @@ import { GOODVIBES_DAEMON_SURFACE_ROOT } from '../../config/surface.ts';
 
 export interface SendStackRoots {
   readonly workingDirectory: string;
-  /** The GoodVibes tree root — the directory `.goodvibes/` sits under. */
+  /** The GoodVibes tree root, the directory `.goodvibes/` sits under. */
   readonly homeDirectory: string;
   /** The daemon's own state root, holding the daemon-scoped secret stores. */
   readonly daemonHomeDirectory: string;
@@ -62,7 +62,7 @@ export interface SendStack {
  * roots (goodvibes-tui and goodvibes-agent) omitted it, still type-checked,
  * still delivered on every surface whose credential happens to sit in config or
  * the environment, and failed only on the surfaces that use a secret reference
- * — at send time, as `Missing Telegram bot token`. This composition root does
+ *, at send time, as `Missing Telegram bot token`. This composition root does
  * not repeat that.
  */
 export function createSendStack(roots: SendStackRoots): SendStack {
@@ -85,7 +85,7 @@ export function createSendStack(roots: SendStackRoots): SendStack {
   });
   const serviceRegistry = new ServiceRegistry(shellPaths.resolveProjectPath(GOODVIBES_DAEMON_SURFACE_ROOT, 'services.json'), {
     secretsManager,
-    subscriptionManager: new SubscriptionManager(shellPaths.resolveUserPath(GOODVIBES_DAEMON_SURFACE_ROOT, 'subscriptions.json')),
+    subscriptionManager: new SubscriptionManager(sharedSubscriptionsPath(shellPaths), { legacyPath: shellPaths.resolveUserPath(GOODVIBES_DAEMON_SURFACE_ROOT, 'subscriptions.json') }),
   });
   const router = new ChannelDeliveryRouter({
     configManager,

package/src/daemon/send/failure-text.ts

@@ -1,5 +1,5 @@
 /**
- * failure-text.ts — what the operator is told when a send does not happen.
+ * failure-text.ts, what the operator is told when a send does not happen.
  *
  * ## Why this is not `summarizeError`
  *
@@ -10,10 +10,10 @@
  *
  *     Telegram delivery failed HTTP 401: {"ok":false,"description":"Unauthorized"}
  *
- * it returns `Telegram delivery failed HTTP 401` — its `stripJson` pass removes
+ * it returns `Telegram delivery failed HTTP 401`, its `stripJson` pass removes
  * the `{...}`, which is exactly the part naming what went wrong. Given
  * `connect ECONNREFUSED 149.154.167.220:443` it returns "Cannot connect to the
- * provider. Check whether the service is reachable." — advice in place of the
+ * provider. Check whether the service is reachable.", advice in place of the
  * address that was refused.
  *
  * A person debugging a message that did not arrive needs the provider's own
@@ -39,7 +39,7 @@ import { redactSensitiveData } from '@pellux/goodvibes-sdk/platform/utils';
 
 /**
  * A generous cap. The point of this text is diagnosis, so it is far larger than
- * the 240 characters `summarizeError` allows — but an HTML error page or a
+ * the 240 characters `summarizeError` allows, but an HTML error page or a
  * multi-megabyte body still must not flood the terminal.
  */
 const MAX_FAILURE_TEXT = 2_000;
@@ -47,10 +47,10 @@ const MAX_FAILURE_TEXT = 2_000;
 const URL_CREDENTIAL_PATTERNS: ReadonlyArray<{ readonly pattern: RegExp; readonly replacement: string }> = [
   // Telegram: the bot token IS the path segment.
   { pattern: /\/bot\d{5,}:[A-Za-z0-9_-]{10,}/g, replacement: '/bot[REDACTED_BOT_TOKEN]' },
-  // Any URL carrying `user:password@host` — BlueBubbles, Mattermost and Matrix
+  // Any URL carrying `user:password@host`, BlueBubbles, Mattermost and Matrix
   // base URLs are all operator-supplied and can be written this way.
   { pattern: /(\b[a-z][a-z0-9+.-]*:\/\/)[^/\s:@]+:[^/\s@]+@/gi, replacement: '$1[REDACTED_CREDENTIALS]@' },
-  // A credential passed as a query parameter — BlueBubbles sends `?password=`.
+  // A credential passed as a query parameter, BlueBubbles sends `?password=`.
   {
     pattern: /([?&](?:password|token|secret|access_token|api_?key|auth)=)[^&\s"']+/gi,
     replacement: '$1[REDACTED]',

package/src/daemon/send/inert-text.ts

@@ -1,5 +1,5 @@
 /**
- * inert-text.ts — make a message arrive as LITERAL TEXT on whichever channel
+ * inert-text.ts, make a message arrive as LITERAL TEXT on whichever channel
  * `goodvibes-daemon send` delivers it to.
  *
  * ## What "inert" means here, and why it is per (surface × transport), not
@@ -12,7 +12,7 @@
  *
  *  - Telegram's `sendMessage` CAN parse MarkdownV2, but the strategy sends with
  *    NO `parse_mode`, which is Telegram's plain-text mode. Running a MarkdownV2
- *    escaper over the body on this path would not protect anything — it would
+ *    escaper over the body on this path would not protect anything, it would
  *    put visible backslashes in front of every `.` `-` `!` `(` in the owner's
  *    message. The correct transform is identity, and the property that makes it
  *    correct is asserted by a test against the real wire payload rather than
@@ -29,7 +29,7 @@
  *
  * `escapeDiscordMarkdown` and `escapeSlackMrkdwn` are the escapers written for
  * the inbound-mail structured notices, in the SDK at
- * `packages/sdk/src/platform/email/inbound-notice.ts` — same character classes,
+ * `packages/sdk/src/platform/email/inbound-notice.ts`, same character classes,
  * same zero-width-space mention break, same rationale. They are reproduced here
  * rather than imported for one reason: that module lives on the unmerged
  * `inbound-email-*` branches and is absent from the published
@@ -72,8 +72,8 @@ function breakMentionForms(text: string): string {
  *
  * `[` `]` `(` `)` are escaped too, and this is REQUIRED rather than
  * precautionary: masked links (`[text](url)`) DO render as clickable in
- * bot-sent and webhook messages — which is exactly how this product delivers to
- * Discord — even though they do not render for text a human typed into the
+ * bot-sent and webhook messages, which is exactly how this product delivers to
+ * Discord, even though they do not render for text a human typed into the
  * client.
  *   https://github.com/discord/discord-api-docs/issues/6096
  *   https://gist.github.com/matthewzring/9f7bbfd102003963f9be7dbcf7d40e51
@@ -97,11 +97,11 @@ function escapeDiscordMarkdown(text: string): string {
  * unescaped `<`.
  *
  * Slack has no backslash escape for `* _ ~ \``, so the zero-width break is
- * applied to those as the best available mitigation — stated as a mitigation,
+ * applied to those as the best available mitigation, stated as a mitigation,
  * not a guarantee, because Slack's whitespace-adjacency rule for what breaks a
  * delimiter pair is not publicly specified to that precision. The residual risk
  * is cosmetic (accidental bold/italic); the injection class this exists to
- * close — a clickable link or a real mention — is closed by the entity escaping
+ * close, a clickable link or a real mention, is closed by the entity escaping
  * above.
  */
 function escapeSlackMrkdwn(text: string): string {
@@ -122,8 +122,8 @@ function escapeGoogleChatMarkup(text: string): string {
 
 /**
  * WhatsApp Cloud API text messages render `*bold*`, `_italic_`, `~strike~` and
- * ```` ```mono``` ````. There is no masked-link syntax — a URL in the body is
- * auto-linked showing its real address — so the injection class Discord has
+ * ```` ```mono``` ````. There is no masked-link syntax, a URL in the body is
+ * auto-linked showing its real address, so the injection class Discord has
  * does not exist here and only the delimiters need neutralizing. WhatsApp
  * documents no backslash escape, so the zero-width break is used.
  */
@@ -136,24 +136,24 @@ function escapeWhatsAppMarkup(text: string): string {
  * markup. Every other routable surface is absent DELIBERATELY, and each absence
  * is a checked claim about the strategy, not an oversight:
  *
- *  - `telegram`  — `sendMessage` without `parse_mode`; Telegram's plain-text
+ *  - `telegram` , `sendMessage` without `parse_mode`; Telegram's plain-text
  *                  mode. Escaping here would corrupt, not protect.
- *  - `ntfy`      — `publish` sends the body as `text/plain` and never sets the
+ *  - `ntfy`     , `publish` sends the body as `text/plain` and never sets the
  *                  `Markdown` header, so ntfy renders it literally. The title
  *                  is derived by `titleFromBody` (first non-empty LINE) and
  *                  passed through `toHeaderSafeTitle`, so no line break or
  *                  non-ASCII byte from the body can reach an HTTP header.
- *  - `webhook`   — the body is a JSON string field; the receiver decides what
+ *  - `webhook`  , the body is a JSON string field; the receiver decides what
  *                  to do with it and there is no markup layer to neutralize.
  *
- *  - `signal`    — the strategy posts `text` to a signal bridge. Signal renders
+ *  - `signal`   , the strategy posts `text` to a signal bridge. Signal renders
  *                  no markup in a plain message body; styling travels as
  *                  explicit range metadata the strategy never sends.
  *  - `imessage`,
- *    `bluebubbles` — both end at iMessage, which renders no markup at all.
- *  - `msteams`   — the strategy sends `textFormat: 'plain'` alongside the text,
+ *    `bluebubbles`, both end at iMessage, which renders no markup at all.
+ *  - `msteams`  , the strategy sends `textFormat: 'plain'` alongside the text,
  *                  which is Teams' own instruction not to parse it.
- *  - `matrix`    — `msgtype: 'm.text'` with no `format`/`formatted_body`. A
+ *  - `matrix`   , `msgtype: 'm.text'` with no `format`/`formatted_body`. A
  *                  Matrix event without the HTML format field is rendered
  *                  literally by clients, per the spec.
  *
@@ -161,7 +161,7 @@ function escapeWhatsAppMarkup(text: string): string {
  * `ControlPlaneGateway` in the same process, which a short-lived CLI does not
  * have, so the command does not offer it as a channel at all. `telephony` is
  * absent because a CLI `send` to it would place a phone call or an SMS through
- * a paid carrier — a different act from messaging a channel — and because the
+ * a paid carrier, a different act from messaging a channel, and because the
  * strategy already XML-escapes the voice path itself via `escapeTwiml`.
  */
 const INERT_TRANSFORMS: Partial<Record<ChannelDeliverySurfaceKind, (text: string) => string>> = {
@@ -173,7 +173,7 @@ const INERT_TRANSFORMS: Partial<Record<ChannelDeliverySurfaceKind, (text: string
   'google-chat': escapeGoogleChatMarkup,
   whatsapp: escapeWhatsAppMarkup,
   // Delivered as plain text by the strategy: transforming would corrupt, not
-  // protect. Each of these is a checked claim about the strategy, not a guess —
+  // protect. Each of these is a checked claim about the strategy, not a guess,
   // see the list above.
   telegram: (text) => text,
   ntfy: (text) => text,

package/src/daemon/send/stdin.ts

@@ -1,5 +1,5 @@
 /**
- * stdin.ts — read the whole of stdin as the message body.
+ * stdin.ts, read the whole of stdin as the message body.
  *
  * Kept out of command.ts so the command stays a pure function of its arguments
  * and its injected dependencies: every test drives it with a stub rather than
@@ -10,8 +10,8 @@
  * Read stdin to end, as UTF-8.
  *
  * There is deliberately no timeout. `send` reads stdin only when the operator
- * gave no message argument AND stdin is not a terminal — meaning something is
- * piping into it — so waiting for that producer to finish is the correct
+ * gave no message argument AND stdin is not a terminal, meaning something is
+ * piping into it, so waiting for that producer to finish is the correct
  * behaviour, and cutting it off at an arbitrary deadline would silently
  * truncate a long message.
  */

package/src/daemon/service-commands.ts

@@ -1,5 +1,5 @@
 /**
- * Service-lifecycle subcommands — `goodvibes-daemon install-service |
+ * Service-lifecycle subcommands, `goodvibes-daemon install-service |
  * uninstall-service | service-status`.
  *
  * The daemon is a SYSTEM SERVICE. These subcommands install it as a durable host
@@ -9,8 +9,8 @@
  *
  * Drift note: the SDK's older `systemd-user-service.ts` (a Linux-only,
  * bespoke systemd shim) was dead code and got deleted from the SDK. The SDK's
- * REAL wired service machinery — reached in production by the daemon's own HTTP
- * `/api/service/*` routes via facade-composition.ts — is
+ * REAL wired service machinery, reached in production by the daemon's own HTTP
+ * `/api/service/*` routes via facade-composition.ts, is
  * `PlatformServiceManager` (`@pellux/goodvibes-sdk/platform/daemon`): a single
  * systemd/launchd/windows-aware manager with install/uninstall/status/start/
  * stop/restart and a `suggestedCommands` hint list. This module now rewires the
@@ -38,16 +38,16 @@
  *     honestly queries systemd via the injected actionRunner) BEFORE the
  *     legacy unit is stopped, disabled, or removed. A failed or unhealthy new
  *     unit rolls itself back (uninstalled) and never touches the legacy one
- *     — a botched takeover must never cost the user their working daemon.
+ *    , a botched takeover must never cost the user their working daemon.
  *   - ADOPT-OR-WARN, NEVER KILL. If the legacy unit file is simply absent but
  *     something is already listening on the configured host:port (Mike's real
  *     dev-host case: a manual `nohup`'d daemon with no unit at all), this is
- *     an unidentified process, not a managed unit — there is nothing to stop
+ *     an unidentified process, not a managed unit, there is nothing to stop
  *     or disable, and this module will not attempt to kill it. It warns and
  *     leaves the decision to the operator.
  *   - Every action (legacy stop/disable, unit-file removal, daemon-reload)
  *     goes through the SAME injectable `actionRunner`/`legacyUnitFileRemove`
- *     seams tests already use — this module never has a code path that bypasses
+ *     seams tests already use, this module never has a code path that bypasses
  *     them, so the migration is exercised deterministically via fakes and never
  *     touches a real running service in tests.
  */
@@ -67,7 +67,7 @@ import {
   type ManagedServiceActionRunner,
 } from '../runtime/legacy-daemon-migration.ts';
 
-// `resolveInstalledDaemonBinary` lives in the runtime module — re-exported
+// `resolveInstalledDaemonBinary` lives in the runtime module, re-exported
 // here so this module stays the CLI's stable public surface (and so existing
 // test imports keep working).
 export {
@@ -83,7 +83,7 @@ export type { ManagedServiceActionRunner } from '../runtime/legacy-daemon-migrat
 // literal name `goodvibes-daemon.service`. This module (rewired onto
 // PlatformServiceManager, see the file banner above) manages a DIFFERENT
 // unit name (`goodvibes`, SERVICE_NAME). A host that still has the legacy
-// unit installed — this dev machine included — would otherwise see
+// unit installed, this dev machine included, would otherwise see
 // service-status honestly report installed:false/running:false for the
 // tracked name while the legacy unit keeps running untouched underneath it,
 // uninstall-service would silently leave the legacy unit orphaned with no
@@ -94,13 +94,13 @@ export type { ManagedServiceActionRunner } from '../runtime/legacy-daemon-migrat
 // migration engine (`runLegacyDaemonMigration`) both live in
 // `../runtime/legacy-daemon-migration.ts` rather than here, because this
 // daemon's own boot-time reconcile (`../runtime/legacy-daemon-reconcile.ts`)
-// needs them too — the entrypoint-agnostic `runtime` layer is what both of
+// needs them too, the entrypoint-agnostic `runtime` layer is what both of
 // this repository's consumers can import, so this CLI module is just one of
 // them. The terminal app's own onboarding guided UX solves the same problem
 // independently, under its own architecture constraints.
 //
 // This detection is entirely independent of PlatformServiceManager's own
-// status() — it does not rely on (or get invalidated by) the parallel SDK
+// status(), it does not rely on (or get invalidated by) the parallel SDK
 // fix that makes status().running itself query systemd honestly for the
 // TRACKED unit name.
 // ---------------------------------------------------------------------------
@@ -125,7 +125,7 @@ export function isDaemonServiceSubcommand(value: string | undefined): value is D
  * Exit codes `service-status` reports, so a script never parses prose.
  *
  * 0/3/4 are the three answers the question actually has; 1 stays what it has
- * always been — the platform refused the query and the error is printed.
+ * always been, the platform refused the query and the error is printed.
  */
 export const SERVICE_STATUS_EXIT_RUNNING = 0;
 export const SERVICE_STATUS_EXIT_INSTALLED_NOT_RUNNING = 3;
@@ -134,10 +134,10 @@ export const SERVICE_STATUS_EXIT_NOT_INSTALLED = 4;
 export interface DaemonServiceCliInput {
   readonly subcommand: DaemonServiceSubcommand;
   readonly binaryPath: string;
-  /** The GoodVibes tree home (GOODVIBES_HOME-overridable) — config/state root only, never unit-path resolution. See `unitHomeDir`. */
+  /** The GoodVibes tree home (GOODVIBES_HOME-overridable), config/state root only, never unit-path resolution. See `unitHomeDir`. */
   readonly homeDir: string;
   /**
-   * The LOGIN user's home — where the systemd/launchd/Windows unit actually
+   * The LOGIN user's home, where the systemd/launchd/Windows unit actually
    * lives, regardless of any GOODVIBES_HOME/GOODVIBES_DAEMON_HOME override.
    * Required (no default to `homeDir`) so a unit-management subcommand can
    * never silently search for its unit under a relocated tree home instead of
@@ -148,14 +148,14 @@ export interface DaemonServiceCliInput {
   readonly port: number;
   /**
    * Whether the invoking CLI line carried an explicit `--hostname`/`--port`
-   * flag (not merely whether `host`/`port` above are set — those are always
+   * flag (not merely whether `host`/`port` above are set, those are always
    * set, resolved from config either way). `install-service`/`migrate-service`
-   * refuse when either is true — see `validateServiceEndpointFlags`. Defaults
+   * refuse when either is true, see `validateServiceEndpointFlags`. Defaults
    * to false (no flag), matching every subcommand these two don't apply to.
    */
   readonly hostnameFlagProvided?: boolean | undefined;
   readonly portFlagProvided?: boolean | undefined;
-  /** Defaults to `homeDir` — overridable so tests can scope both to one tempdir. */
+  /** Defaults to `homeDir`, overridable so tests can scope both to one tempdir. */
   readonly workingDirectory?: string | undefined;
   /** Injected in tests; a real `ConfigManager` rooted at `homeDir` otherwise. */
   readonly configManager?: ConfigManager | undefined;
@@ -166,7 +166,7 @@ export interface DaemonServiceCliInput {
   /**
    * `migrate-service` only: explicit consent to actually execute the
    * migration (wired from the CLI's `-y`/`--yes` flag). Without it, the
-   * subcommand prints the exact plan and changes nothing — never auto-migrate.
+   * subcommand prints the exact plan and changes nothing, never auto-migrate.
    */
   readonly confirmMigration?: boolean | undefined;
   /**
@@ -183,7 +183,7 @@ export interface DaemonServiceCliInput {
   readonly legacyUnitFileRemove?: ((path: string) => void) | undefined;
   /**
    * `service-status` only: report one JSON document instead of prose. The exit
-   * code is the same either way — the codes are the machine-readable answer,
+   * code is the same either way, the codes are the machine-readable answer,
    * and JSON is for when a script wants the fields as well.
    */
   readonly json?: boolean | undefined;
@@ -200,7 +200,7 @@ export interface DaemonServiceCliResult {
 /**
  * The manager's definition (`ExecStart` command/args, name, description) is
  * built once, in `../runtime/legacy-daemon-migration.ts`, and shared with the
- * onboarding guided UX — see that module's doc comment for why.
+ * onboarding guided UX, see that module's doc comment for why.
  */
 function buildManager(input: DaemonServiceCliInput): PlatformServiceManager {
   return buildManagedDaemonServiceManager({
@@ -225,12 +225,12 @@ function statusLines(status: ManagedServiceStatus): string[] {
   if (status.pid !== undefined) lines.push(`pid: ${status.pid}`);
   if (status.platform !== 'manual' && status.installed && !status.running) {
     // W3 Finding 4: this used to assert "'running' here only reflects
-    // processes this tool started directly" — true for the pid-file-only
+    // processes this tool started directly", true for the pid-file-only
     // check the (currently linked) SDK still uses, but the parallel SDK
     // batch is making status().running query systemd honestly via
     // `is-active`, which would make that specific claim stale. Drop the
     // claim about HOW running was computed and just offer the escape
-    // hatch — true and useful under either SDK version.
+    // hatch, true and useful under either SDK version.
     lines.push(
       `note: if this looks wrong, verify directly: ${status.suggestedCommands[status.suggestedCommands.length - 1] ?? 'the platform service-status command'}`,
     );
@@ -264,7 +264,7 @@ export function buildInstallResultLines(status: ManagedServiceStatus): string[]
  * Every line names the RESOLVED unit (`status.serviceName`, `status.path`) and
  * says what the platform reported afterwards, rather than asserting the verb
  * worked because it was dispatched without throwing. A verb aimed at a service
- * that is not installed says exactly that — installing it silently would be a
+ * that is not installed says exactly that, installing it silently would be a
  * different command than the one that was run.
  */
 export function buildLifecycleResultLines(
@@ -364,7 +364,7 @@ function ok(action: 'install' | 'uninstall' | 'status', status: ManagedServiceSt
     lines.push(`removed the ${status.platform} service at ${status.path}`);
     if (status.platform === 'systemd') {
       lines.push(
-        "note: this removes the unit file but does not run `disable` — run " +
+        "note: this removes the unit file but does not run `disable`; run " +
           "`systemctl --user daemon-reload` to clear any stale enablement symlink.",
       );
     }
@@ -388,12 +388,12 @@ function failed(action: 'install' | 'uninstall' | 'status', status: ManagedServi
  * `install-service` and `migrate-service` refuse an explicit
  * `--hostname`/`--port` flag rather than silently accepting it. Both flags are
  * RUNTIME-ONLY overrides applied to this one invocation's in-memory config
- * (`applyRuntimeEndpointFlagOverrides` in `src/daemon/cli.ts`) — but the unit
+ * (`applyRuntimeEndpointFlagOverrides` in `src/daemon/cli.ts`), but the unit
  * this subcommand writes carries no endpoint flags at all (see
  * `buildManagedDaemonServiceManager`'s ExecStart doc): the daemon always
  * re-resolves `controlPlane.host`/`port`/`hostMode` from PERSISTED settings at
  * boot. A flag accepted here would print/probe a binding the installed unit
- * will never actually have — an honest gap, not a cosmetic one, since the
+ * will never actually have, an honest gap, not a cosmetic one, since the
  * printed value is exactly what an operator would expect the running service
  * to bind to. Refusing with a pointer to the persistent config path is
  * strictly better than silently doing nothing with the flag.
@@ -408,7 +408,7 @@ export function validateServiceEndpointFlags(
     .filter((name): name is string => name !== null)
     .join('/');
   return [
-    `${subcommand} refused: ${flagNames} only override this process's runtime config — the installed unit carries ` +
+    `${subcommand} refused: ${flagNames} only override this process's runtime config; the installed unit carries ` +
       'no endpoint flags and re-resolves controlPlane.host/port/hostMode from persisted settings at boot, so the ' +
       'override would never take effect there.',
     `Set the persistent binding instead: goodvibes-daemon config set controlPlane.host / controlPlane.port (or ` +
@@ -419,7 +419,7 @@ export function validateServiceEndpointFlags(
 /**
  * `migrate-service`: the guided, consented takeover of the legacy
  * `goodvibes-daemon.service` unit. Thin wrapper over
- * `runLegacyDaemonMigration` (`../runtime/legacy-daemon-migration.ts`) — see
+ * `runLegacyDaemonMigration` (`../runtime/legacy-daemon-migration.ts`), see
  * that module for the design constraints (never auto-migrate,
  * new-up-then-old-down, adopt-or-warn/never kill an unrecognized process,
  * every action through an injectable seam) and the onboarding UX consumer.
@@ -461,7 +461,7 @@ export async function runDaemonServiceCli(input: DaemonServiceCliInput): Promise
     case 'install-service': {
       // W3 Finding 4: refuse rather than risk starting a second daemon
       // alongside an already-installed legacy unit. Refuses whenever the
-      // legacy unit is present at all (not just when currently active) —
+      // legacy unit is present at all (not just when currently active),
       // an installed-but-inactive legacy unit can still be enabled and
       // start competing for the same port later, and "never silently
       // start a second daemon" is the bar here, not "never right now."
@@ -483,7 +483,7 @@ export async function runDaemonServiceCli(input: DaemonServiceCliInput): Promise
       if (installed.actionError) return failed('install', installed);
       const started = manager.start();
       // start()'s actionError (e.g. a platform this manager can't dispatch
-      // actions for) doesn't undo the write — report install as ok, but surface
+      // actions for) doesn't undo the write, report install as ok, but surface
       // the follow-up problem honestly instead of claiming it is running.
       return started.actionError
         ? ok('install', { ...started, running: false }, [`could not start it automatically: ${started.actionError}`])
@@ -496,7 +496,7 @@ export async function runDaemonServiceCli(input: DaemonServiceCliInput): Promise
       const extra: string[] = [];
       if (stopped.actionError) extra.push(`(it may not have been running: ${stopped.actionError})`);
       // This command only ever touches the TRACKED unit (whatever name/path
-      // actually resolved — not necessarily the SERVICE_NAME constant) above —
+      // actually resolved, not necessarily the SERVICE_NAME constant) above,
       // say so explicitly when an install-script unit also exists, so its
       // continued presence is never a silent surprise.
       if (legacy.present) extra.push(legacyUnitNote(legacy, resolveManagedUnitName(uninstalled)));
@@ -520,8 +520,8 @@ export async function runDaemonServiceCli(input: DaemonServiceCliInput): Promise
         };
       }
       const result = ok('status', status, legacy.present ? [legacyUnitNote(legacy, resolveManagedUnitName(status))] : []);
-      // The status verb reports; it does not fail. `ok` is still true — the
-      // question was answered — while the exit code carries the answer itself
+      // The status verb reports; it does not fail. `ok` is still true, the
+      // question was answered, while the exit code carries the answer itself
       // (0 running / 3 installed-not-running / 4 not installed), so a script
       // never has to read the prose above.
       return { ...result, exitCode: serviceStatusExitCode(status) };

package/src/daemon/sessions-command.ts

@@ -1,14 +1,14 @@
 /**
- * sessions-command.ts — `goodvibes-daemon sessions list|kill <id>`.
+ * sessions-command.ts, `goodvibes-daemon sessions list|kill <id>`.
  *
  * The sessions this daemon HOSTS: conversation loops running inside it, which
  * outlive the client that started them. That is the whole reason they need a
- * command — a terminal's own session dies with the terminal and never needs
+ * command, a terminal's own session dies with the terminal and never needs
  * listing from outside, while a hosted one can be running on a headless box
  * with nothing attached to it at all.
  *
  * The verbs are `sessions.hosted.list` and `sessions.hosted.kill`, and both are
- * declared ws-only in the method catalog — they have no REST binding, so they
+ * declared ws-only in the method catalog, they have no REST binding, so they
  * go through `callDaemonWsVerb` rather than `callDaemonVerb`. Same target, same
  * operator token, same --host/--port/--token convention; only the transport is
  * different. A daemon built without hosted sessions answers "does not know the
@@ -62,7 +62,7 @@ export interface SessionsCommandFlags extends RemoteCommandFlags {
 
 export interface RunSessionsCommandInput extends RemoteCommandDeps {
   readonly flags: SessionsCommandFlags;
-  /** Positional words after `sessions` — the subcommand and its argument. */
+  /** Positional words after `sessions`, the subcommand and its argument. */
   readonly args: readonly string[];
 }
 
@@ -119,7 +119,7 @@ function renderSession(session: HostedSessionRecord, now: number): string[] {
  *
  * Exit 0 when the daemon answered, 1 when it refused or could not be reached,
  * 2 when the command line was wrong. A `kill` with no id is a usage refusal
- * rather than a "kill everything" — there is no shape of this command that ends
+ * rather than a "kill everything", there is no shape of this command that ends
  * more than the one session named.
  */
 export async function runSessionsCommand(input: RunSessionsCommandInput): Promise<DaemonCommandResult> {
@@ -129,11 +129,11 @@ export async function runSessionsCommand(input: RunSessionsCommandInput): Promis
     return refusal('name what to do with the sessions.', flags.json);
   }
   if (!isSessionsSubcommand(subcommand)) {
-    return refusal(`'${subcommand}' is not a sessions command — try list or kill.`, flags.json);
+    return refusal(`'${subcommand}' is not a sessions command; try list or kill.`, flags.json);
   }
   const sessionId = args[1];
   if (subcommand === 'kill' && sessionId === undefined) {
-    return refusal('kill needs the session to end — run `sessions list` to see them.', flags.json);
+    return refusal('kill needs the session to end; run `sessions list` to see them.', flags.json);
   }
   if (args.length > (subcommand === 'kill' ? 2 : 1)) {
     return refusal(`'${args[subcommand === 'kill' ? 2 : 1]}' is one argument too many.`, flags.json);