@pellux/goodvibes-tui 2.0.14 → 2.0.15

package/src/cli/help.ts

@@ -7,7 +7,7 @@ function readJsonVersion(path: string): string | null {
   try {
     if (!existsSync(path)) return null;
     const parsed = JSON.parse(readFileSync(path, 'utf-8')) as { name?: unknown; version?: unknown };
-    // Only trust OUR package.json — a compiled single-file binary can resolve
+    // Only trust OUR package.json, a compiled single-file binary can resolve
     // this path to a different package.json (a bundled dependency's) that
     // reports a placeholder like "0.0.0". Fall through to the baked VERSION in
     // that case rather than rendering a stray version in `--version`/banners.
@@ -30,7 +30,7 @@ export function renderGoodVibesVersion(binary = 'goodvibes'): string {
 
 /**
  * Honest one-line startup identity for the daemon binary, emitted right as it
- * begins serving — including on a bare (no-arg) systemd launch. It states the
+ * begins serving, including on a bare (no-arg) systemd launch. It states the
  * RESOLVED version (never a placeholder), the home/host/port it actually bound,
  * and points at the real service-setup command. This replaces the field
  * behavior where a bare launch showed a wrong "v0.0.0" banner and gave an
@@ -44,7 +44,7 @@ export function renderDaemonStartupBanner(
   binary = 'goodvibes-daemon',
 ): string {
   return (
-    `${binary} ${version} starting — ` +
+    `${binary} ${version} starting: ` +
     `home=${binding.homeDir} host=${binding.host} port=${binding.port} ` +
     `(manage as a service: ${binary} install-service)`
   );
@@ -257,12 +257,12 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
   },
   hooks: {
     usage: ['hooks validate'],
-    summary: 'Validate the configured hooks.json against the hook loader schema — per-hook pass/fail with plain reasons, nonzero exit if any hook is invalid.',
+    summary: 'Validate the configured hooks.json against the hook loader schema; per-hook pass/fail with plain reasons, nonzero exit if any hook is invalid.',
     examples: ['hooks validate', 'hooks validate --json'],
   },
   plugin: {
     usage: ['plugin init <name> [directory]', 'plugin validate <path>', 'plugin bundles browse <index-url-or-file>', 'plugin bundles install <ref> --sha256 <pin>', 'plugin bundles list'],
-    summary: 'Scaffold a minimal valid plugin (manifest.json + entry file), validate a plugin directory against the plugin loader checks, or browse/install/list SHA-256-pinned capability bundles from a governed marketplace index. Bundle installs are never unpinned — a missing or mismatched --sha256 is refused, not overridable.',
+    summary: 'Scaffold a minimal valid plugin (manifest.json + entry file), validate a plugin directory against the plugin loader checks, or browse/install/list SHA-256-pinned capability bundles from a governed marketplace index. Bundle installs are never unpinned; a missing or mismatched --sha256 is refused, not overridable.',
     examples: ['plugin init my-plugin', 'plugin validate .goodvibes/plugins/my-plugin', 'plugin bundles browse ./marketplace-index.json', 'plugin bundles install ./bundle.json --sha256 <64-hex> --yes'],
   },
 };
@@ -340,7 +340,7 @@ export function renderGoodVibesDaemonHelp(binary = 'goodvibes-daemon'): string {
     '  service-status                 Show whether the daemon service is installed / enabled / active',
     '  migrate-service                Guided migration from an install-script goodvibes-daemon.service unit; prints a plan',
     '                                 unless run with -y/--yes (never auto-migrates)',
-    '  send [message]                 Send a message to one of your configured channels — Telegram, ntfy,',
+    '  send [message]                 Send a message to one of your configured channels: Telegram, ntfy,',
     '                                 Discord, Slack, Google Chat, Signal, WhatsApp, iMessage, Teams,',
     '                                 BlueBubbles, Mattermost, Matrix or a webhook. Takes the message as',
     '                                 an argument or on stdin, so it composes with other tooling.',

package/src/cli/hooks-command.ts

@@ -2,10 +2,10 @@ import { buildHooksValidation } from './hooks-report.ts';
 import type { CliCommandOutput, CliCommandRuntime } from '@pellux/goodvibes-terminal-shell';
 
 // ---------------------------------------------------------------------------
-// `goodvibes hooks validate` — validate the user's hooks.json against the
+// `goodvibes hooks validate`, validate the user's hooks.json against the
 // hooks loader's REAL schema. The acceptance verdict comes from
 // buildHooksValidation (src/cli/hooks-report.ts), which runs the SDK's own
-// HookDispatcher.loadFromFile and getHookPointContract — the same machinery
+// HookDispatcher.loadFromFile and getHookPointContract, the same machinery
 // `goodvibes doctor hooks` reuses. This command only reads and reports.
 // ---------------------------------------------------------------------------
 
@@ -23,7 +23,7 @@ export async function handleHooksCommand(runtime: CliCommandRuntime): Promise<Cl
     const text = [
       'GoodVibes hooks validation',
       `  file: ${path}`,
-      '  no hooks file present — nothing to validate.',
+      '  no hooks file present: nothing to validate.',
     ].join('\n');
     return { output: json ? JSON.stringify({ path, present: false, hooks: [], valid: true }, null, 2) : text, exitCode: 0 };
   }
@@ -62,7 +62,7 @@ export async function handleHooksCommand(runtime: CliCommandRuntime): Promise<Cl
       const detail = c ? ` (contract: ${c.authority}/${c.executionMode})` : '';
       lines.push(`  PASS  ${label}${detail}`);
     } else {
-      lines.push(`  FAIL  ${label} — ${check.reason}`);
+      lines.push(`  FAIL  ${label}: ${check.reason}`);
     }
   }
   if (chains.declared > 0 || chains.accepted > 0) {

package/src/cli/hooks-report.ts

@@ -11,7 +11,7 @@ import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 // acceptance comes from running the SDK's own HookDispatcher.loadFromFile (the
 // same loader the app uses at startup), and the "is this a real hook event
 // point" verdict comes from the SDK's getHookPointContract. This module only
-// reads and reports — it changes no config and fires no hooks.
+// reads and reports, it changes no config and fires no hooks.
 // ---------------------------------------------------------------------------
 
 /** Per-hook acceptance verdict, keyed to the on-disk position it was declared at. */
@@ -28,7 +28,7 @@ export interface HookCheck {
 
 /** The full validation result for one hooks file. */
 export interface HooksValidation {
-  /** Absolute path the app resolves `tools.hooksFile` to — the "from where" of every hook. */
+  /** Absolute path the app resolves `tools.hooksFile` to, the "from where" of every hook. */
   readonly path: string;
   readonly present: boolean;
   readonly valid: boolean;
@@ -42,7 +42,7 @@ export interface HooksValidation {
 }
 
 export const LOADER_FIELD_REASON =
-  "the hooks loader skipped this entry — a hook needs a string \"match\" and a \"type\" of command, prompt, agent, http, or ts";
+  "the hooks loader skipped this entry; a hook needs a string \"match\" and a \"type\" of command, prompt, agent, http, or ts";
 
 /** Build a consumable multiset of the loader-accepted definitions, keyed by pattern. */
 function acceptedMultiset(accepted: Map<string, HookDefinition[]>): Map<string, Map<string, number>> {
@@ -100,7 +100,7 @@ export function buildHooksValidation(configManager: Pick<ConfigManager, 'get' |
   try {
     parsed = JSON.parse(readFileSync(path, 'utf-8'));
   } catch (error) {
-    return { path, present: true, valid: false, reason: `hooks.json is not valid JSON — ${summarizeError(error)}`, topLevelIssues: [], checks: [], chains: { declared: 0, accepted: 0 }, passCount: 0, failCount: 1 };
+    return { path, present: true, valid: false, reason: `hooks.json is not valid JSON; ${summarizeError(error)}`, topLevelIssues: [], checks: [], chains: { declared: 0, accepted: 0 }, passCount: 0, failCount: 1 };
   }
 
   if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {

package/src/cli/launch-auto-update.ts

@@ -1,23 +1,23 @@
 /**
- * Launch-time self-update — clients land on the newest release at startup so
+ * Launch-time self-update, clients land on the newest release at startup so
  * an installed binary never drifts behind. At TUI launch (before any runtime
  * bootstrap or terminal mode change) this runs a quick version check and, when
  * a newer release exists, installs it through the SAME checksum-verified
  * download/verify/swap path `/update apply` and the suite installer use
- * (src/input/commands/update-runtime.ts — there is deliberately no second
+ * (src/input/commands/update-runtime.ts, there is deliberately no second
  * updater), then asks the caller to restart onto the new binary.
  *
  * Honesty rules, in both directions:
  *   - the check gets a short timeout; when it cannot complete (offline, slow
  *     network) the CURRENT version starts with exactly one line saying the
- *     check was skipped — launch is never held hostage by the network.
+ *     check was skipped, launch is never held hostage by the network.
  *   - a successful update restarts into the new binary and the restarted
  *     process prints a receipt naming both versions, so the swap is never
  *     silent.
  *   - the install gets a budget too, and running out of it is reported for
  *     what actually happened rather than assumed. The budget cancels the work
  *     through a real AbortSignal, so a download that is still in flight is
- *     genuinely stopped and "deferred — will retry next launch" is true. Once
+ *     genuinely stopped and "deferred, will retry next launch" is true. Once
  *     the swap has begun it is never interrupted, so that outcome says the
  *     binary WAS replaced and asks for a restart instead. The two are told
  *     apart by the swap state the install reports back (UpdateSwapProgress),
@@ -27,12 +27,12 @@
  *
  * The feature is a real configurable setting (`update.autoUpdateAtLaunch` in
  * settings.json, read via readUpdateSettings): default ON, off with an
- * explicit false. Only binary installs self-update — package-manager and
+ * explicit false. Only binary installs self-update, package-manager and
  * from-source runs are skipped silently because a swap there would fight the
  * package manager (see detectInstallKind).
  *
  * Everything effectful is injectable; tests drive the decision logic with a
- * stubbed fetch, a stubbed apply, and pinned fixture versions — never the
+ * stubbed fetch, a stubbed apply, and pinned fixture versions, never the
  * live build VERSION and never the real network.
  */
 import { spawnSync } from 'node:child_process';
@@ -61,7 +61,7 @@ export const LAUNCH_UPDATED_FROM_ENV = 'GOODVIBES_LAUNCH_UPDATED_FROM';
 /** Default budget for the launch-time version check; user-tunable via update.launchCheckTimeoutMs. */
 export const LAUNCH_UPDATE_CHECK_TIMEOUT_MS = 2500;
 
-/** Default budget for the launch-time download+verify+swap; user-tunable via update.applyTimeoutMs. Generous — a binary download over a slow connection genuinely takes a while — but bounded so launch is never held hostage. */
+/** Default budget for the launch-time download+verify+swap; user-tunable via update.applyTimeoutMs. Generous, a binary download over a slow connection genuinely takes a while, but bounded so launch is never held hostage. */
 export const LAUNCH_APPLY_TIMEOUT_MS = 45_000;
 
 export type LaunchAutoUpdateOutcome =
@@ -144,11 +144,11 @@ export async function runLaunchAutoUpdate(options: RunLaunchAutoUpdateOptions):
     check = 'timeout';
   }
   if (check === 'timeout') {
-    // Honest about WHY the check was skipped — a timeout most commonly means
+    // Honest about WHY the check was skipped, a timeout most commonly means
     // the update server could not be reached in time, not necessarily that
     // the whole machine is offline (a slow/flaky connection is just as
     // common), so this no longer overclaims "offline".
-    options.print("couldn't reach the update server — check skipped");
+    options.print("couldn't reach the update server; check skipped");
     return { action: 'continue', reason: 'check-skipped' };
   }
   if (check.isCurrent) {
@@ -181,23 +181,23 @@ export async function runLaunchAutoUpdate(options: RunLaunchAutoUpdateOptions):
     if (applyResult === 'timeout') {
       if (!progress.begun) {
         // Nothing has been written yet, so the work can genuinely be called
-        // off — cancel the download in flight, then say it was deferred.
+        // off, cancel the download in flight, then say it was deferred.
         controller.abort();
-        options.print('update deferred — will retry next launch');
+        options.print('update deferred: will retry next launch');
         return { action: 'continue', reason: 'update-deferred' };
       }
       // The swap had already started when the budget ran out. A swap is never
-      // interrupted, so the binary on disk is the new one — cancelling here
+      // interrupted, so the binary on disk is the new one, cancelling here
       // would be a lie in the other direction. Report the replacement and the
       // restart it needs instead of claiming a deferral that did not happen.
       options.print(`updated in background; restart to use v${normalizeVersion(progress.targetTag ?? check.latestTag)}`);
       return { action: 'continue', reason: 'update-in-background' };
     }
-    options.print(`auto-update: ${check.latestTag} installed — restarting onto the new version`);
+    options.print(`auto-update: ${check.latestTag} installed; restarting onto the new version`);
     return { action: 'restart', latestTag: check.latestTag };
   } catch (error) {
     options.print(
-      `auto-update failed: ${error instanceof Error ? error.message : String(error)} — starting the current version v${normalizeVersion(options.currentVersion)}`,
+      `auto-update failed: ${error instanceof Error ? error.message : String(error)}; starting the current version v${normalizeVersion(options.currentVersion)}`,
     );
     return { action: 'continue', reason: 'update-failed' };
   }
@@ -214,7 +214,7 @@ export interface SelfUpdateAtLaunchParams {
  * binary and EXIT THIS PROCESS with the new instance's exit code (this call
  * never returns in that case); otherwise return the honest lines that were
  * printed (receipt / skipped check / failed update) so the caller can
- * re-surface them through the system message router once it exists — the
+ * re-surface them through the system message router once it exists, the
  * stdout copies written here are wiped by the TUI's alternate screen.
  */
 export async function selfUpdateAtLaunch(params: SelfUpdateAtLaunchParams): Promise<readonly string[]> {
@@ -262,7 +262,7 @@ export interface HandDaemonOverAtLaunchParams {
  * The launch wiring for the old→new daemon handover (src/runtime/daemon-handover.ts).
  *
  * A daemon binary from before the split cannot update itself onto its own
- * release line — the releases URL baked into it names this repository, which no
+ * release line, the releases URL baked into it names this repository, which no
  * longer builds daemons, and pointing it at the daemon's repository instead
  * still fails because its shipped updater insists on downloading the terminal
  * binary beside it, which that repository does not publish. So the terminal
@@ -300,7 +300,7 @@ export interface RestartOntoUpdatedBinaryOptions {
   readonly execPath: string;
   readonly argv: readonly string[];
   readonly env: NodeJS.ProcessEnv;
-  /** The version that performed the update — the restarted process prints it in its receipt line. */
+  /** The version that performed the update, the restarted process prints it in its receipt line. */
   readonly fromVersion: string;
   /** Injectable so tests observe the restart instead of spawning a process. */
   readonly spawn?: (execPath: string, argv: readonly string[], env: NodeJS.ProcessEnv) => number | null;

package/src/cli/management-commands.ts

@@ -315,7 +315,7 @@ export interface ControlPlaneStatusResult {
   readonly port: number;
   readonly recognized: boolean;
   readonly posture: ReturnType<typeof classifyBindPosture>;
-  /** undefined = NOT PROBED (unrecognized host mode) — a tri-state, never coerced to false. */
+  /** undefined = NOT PROBED (unrecognized host mode), a tri-state, never coerced to false. */
   readonly reachable: boolean | undefined;
   readonly auth: ReturnType<typeof readAuthPaths>;
   readonly service: {
@@ -329,7 +329,7 @@ export interface ControlPlaneStatusResult {
 export async function buildControlPlaneStatusResult(runtime: CliCommandRuntime): Promise<ControlPlaneStatusResult> {
   const binding = resolveRuntimeEndpointBinding(runtime.configManager, 'controlPlane');
   const enabled = runtime.configManager.get('controlPlane.enabled');
-  // Never TCP-probe the fallback endpoint of an unrecognized hostMode — a
+  // Never TCP-probe the fallback endpoint of an unrecognized hostMode, a
   // probe asserts a binding that does not exist. Not-probed is its own state
   // (undefined), NEVER coerced to a definite false: a daemon launched with
   // flag overrides can be serving healthily regardless of the stored mode.
@@ -343,7 +343,7 @@ export async function buildControlPlaneStatusResult(runtime: CliCommandRuntime):
     restartOnFailure: runtime.configManager.get('service.restartOnFailure'),
   };
   const issues: string[] = [];
-  if (!binding.recognized) issues.push(`controlPlane.hostMode '${binding.hostMode}' is not a recognized mode (local|network|custom) — the daemon cannot bind until it is corrected.`);
+  if (!binding.recognized) issues.push(`controlPlane.hostMode '${binding.hostMode}' is not a recognized mode (local|network|custom); the daemon cannot bind until it is corrected.`);
   if (enabled === true && binding.recognized && !reachable) issues.push(`Control plane is enabled but not reachable on ${binding.host}:${binding.port}.`);
   if (enabled === true && service.enabled !== true) issues.push('Control plane is enabled but service mode is off.');
   if (enabled === true && service.autostart !== true) issues.push('Control plane is enabled but service autostart is off.');
@@ -408,7 +408,7 @@ export async function renderPairing(runtime: CliCommandRuntime): Promise<string>
     const link = result.deepLink ?? result.fragment;
     const qr = renderQrToString(generateQrMatrix(link));
     const lines: string[] = [
-      'Scan to pair a device — the QR opens the web app already signed in:',
+      'Scan to pair a device; the QR opens the web app already signed in:',
       '',
       `  ${link}`,
       `  Token name: ${result.token.name}  (rename or revoke later in /settings → security → devices)`,
@@ -417,7 +417,7 @@ export async function renderPairing(runtime: CliCommandRuntime): Promise<string>
       lines.push('', 'Offers carried in this pairing (each declinable in the web app):', ...formatPairingOffers(result.offers.map((o) => o.kind)));
     }
     // The labeled browser-capability list and the one honest LAN line both render
-    // from the SDK posture the verb returned — never a locally-authored string.
+    // from the SDK posture the verb returned, never a locally-authored string.
     const capabilities = formatPostureCapabilities(result.posture);
     if (capabilities.length > 0) lines.push('', 'This device will get:', ...capabilities);
     const notice = pairingPostureNotice(result.posture);
@@ -440,8 +440,8 @@ interface TailscaleGetResult {
 /**
  * Read-only tailscale detection for the `gv pair` block: when tailscale is
  * available with a served https MagicDNS URL, name the encrypted path (the
- * interactive one-action serve lives in the pairing modal). Quiet — an empty
- * array — when tailscale is absent or the probe fails.
+ * interactive one-action serve lives in the pairing modal). Quiet, an empty
+ * array, when tailscale is absent or the probe fails.
  */
 async function renderPairingTailscaleLines(services: RuntimeServices): Promise<string[]> {
   try {
@@ -451,7 +451,7 @@ async function renderPairingTailscaleLines(services: RuntimeServices): Promise<s
     })) as TailscaleGetResult;
     if (!ts.available) return [];
     if (ts.httpsUrl) return ['', `Encrypted access (Tailscale): ${ts.httpsUrl}`];
-    return ['', 'Tailscale detected — run it as a serve target for encrypted https access (see the pairing modal).'];
+    return ['', 'Tailscale detected: run it as a serve target for encrypted https access (see the pairing modal).'];
   } catch {
     return [];
   }

package/src/cli/management-utils.ts

@@ -1,5 +1,5 @@
 /**
- * management-utils.ts — shared CLI utility functions.
+ * management-utils.ts, shared CLI utility functions.
  *
  * Extracted from management.ts to break the import cycle:
  *   management.ts ↔ management-commands.ts
@@ -10,7 +10,7 @@
  * for these utilities).
  *
  * No imports from management-commands.ts or surface-command.ts are allowed
- * in this file — that would recreate the cycle.
+ * in this file, that would recreate the cycle.
  */
 
 import { existsSync, readFileSync } from 'node:fs';
@@ -326,7 +326,7 @@ export async function runNonInteractiveAgent(runtime: CliCommandRuntime): Promis
 
   try {
     // Async pre-turn refresh of the memory-spine recall snapshot (SDK 1.2.0
-    // full-detach) — see the matching comment in main.ts's submitInput.
+    // full-detach), see the matching comment in main.ts's submitInput.
     await refreshMemoryRecallSnapshot(ctx.services);
     await ctx.orchestrator.handleUserInput(prompt);
     await done;

package/src/cli/management.ts

@@ -282,7 +282,7 @@ async function renderModels(runtime: CliCommandRuntime): Promise<string> {
       ].join('\n'));
     }
     if (subOrFilter === 'chain' || subOrFilter === 'chains') {
-      // List synthetic model fallback ladders — backend composition for each synthetic model.
+      // List synthetic model fallback ladders, backend composition for each synthetic model.
       const canonicalModels = services.providerRegistry.getSyntheticCanonicalModels();
       if (canonicalModels.length === 0) {
         return formatJsonOrText(runtime.cli)([], 'No synthetic models found in the current catalog.');

package/src/cli/plugin-bundles-command.ts

@@ -14,11 +14,11 @@ import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import type { CliCommandOutput, CliCommandRuntime } from '@pellux/goodvibes-terminal-shell';
 
 // ---------------------------------------------------------------------------
-// `goodvibes plugin bundles browse|install|list` — the capability-bundle
+// `goodvibes plugin bundles browse|install|list`, the capability-bundle
 // marketplace surface. Extends the existing plugin-command.ts family with the
 // SDK's SHA-256-pinned bundle distribution (platform/runtime/ecosystem):
 // parseMarketplaceIndex, fetchAndVerifyBundle, planBundleActivation. There is
-// deliberately NO flag that bypasses a pin mismatch — `install` either
+// deliberately NO flag that bypasses a pin mismatch, `install` either
 // verifies or refuses; `--yes` only confirms an ALREADY-verified activation
 // plan, it never substitutes for the pin.
 // ---------------------------------------------------------------------------
@@ -59,7 +59,7 @@ function formatJsonOrText(runtime: CliCommandRuntime, value: unknown, text: stri
   return runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(value, null, 2) : text;
 }
 
-/** file:// / bare-path vs http(s):// — the only two source kinds this CLI surface accepts (no git ref flag exists yet). */
+/** file:// / bare-path vs http(s)://, the only two source kinds this CLI surface accepts (no git ref flag exists yet). */
 function inferSourceKind(ref: string): 'file' | 'url' {
   return ref.startsWith('http://') || ref.startsWith('https://') ? 'url' : 'file';
 }
@@ -111,7 +111,7 @@ async function handleBrowse(runtime: CliCommandRuntime, ref: string | undefined)
   const lines = [`Marketplace index at '${ref}' (${bundles.length} bundle${bundles.length === 1 ? '' : 's'}):`];
   for (const entry of bundles) {
     lines.push(
-      `  ${entry.id} — ${entry.name} v${entry.version} (${entry.kind})`,
+      `  ${entry.id}: ${entry.name} v${entry.version} (${entry.kind})`,
       `    ${entry.summary}`,
       `    capabilities: ${summarizeCapabilities(entry.capabilities)}`,
       `    pin: sha256:${entry.source.sha256} (${entry.source.kind}: ${entry.source.location})`,
@@ -123,7 +123,7 @@ async function handleBrowse(runtime: CliCommandRuntime, ref: string | undefined)
 /** Render an activation plan (granted capabilities, withheld/quarantined ones) for confirmation. */
 function renderPlan(plan: BundleActivationPlan, committed: boolean): string {
   const lines = [
-    `${committed ? 'Installed' : 'Activation plan (preview — re-run with --yes to install)'}: ${plan.manifest.id} v${plan.manifest.version} (${plan.manifest.kind})`,
+    `${committed ? 'Installed' : 'Activation plan (preview; re-run with --yes to install)'}: ${plan.manifest.id} v${plan.manifest.version} (${plan.manifest.kind})`,
     `  trust tier: ${plan.trustTier}`,
     `  declared runtime capabilities: ${plan.manifest.capabilities.runtime.join(', ') || 'none'}`,
     `  declared tools: ${plan.manifest.capabilities.tools.join(', ') || 'none'}`,
@@ -134,18 +134,18 @@ function renderPlan(plan: BundleActivationPlan, committed: boolean): string {
   ];
   if (plan.quarantine.required) {
     lines.push(
-      `  QUARANTINED: yes — ${plan.quarantine.reason ?? 'over-reached its trust tier'}`,
+      `  QUARANTINED: yes; ${plan.quarantine.reason ?? 'over-reached its trust tier'}`,
       `  withheld capabilities: ${plan.quarantine.revokedCapabilities.join(', ')}`,
     );
   } else {
-    lines.push('  quarantined: no — every declared capability fit the trust tier');
+    lines.push('  quarantined: no; every declared capability fit the trust tier');
   }
   return lines.join('\n');
 }
 
 async function handleInstall(runtime: CliCommandRuntime, ref: string | undefined, sha256: string | undefined): Promise<CliCommandOutput> {
   if (!ref || !sha256) {
-    return { output: 'Usage: goodvibes plugin bundles install <ref> --sha256 <pin>  (the pin is required — there is no unpinned install path)', exitCode: 2 };
+    return { output: 'Usage: goodvibes plugin bundles install <ref> --sha256 <pin>  (the pin is required; there is no unpinned install path)', exitCode: 2 };
   }
   const kind = inferSourceKind(ref);
   const source = { kind, location: ref, sha256 } as const;
@@ -205,10 +205,10 @@ function handleList(runtime: CliCommandRuntime): CliCommandOutput {
   const lines = [`Installed capability bundles (${records.length}):`];
   for (const record of records) {
     lines.push(
-      `  ${record.id} — ${record.name} v${record.version} (${record.kind})`,
+      `  ${record.id}: ${record.name} v${record.version} (${record.kind})`,
       `    installedAt: ${new Date(record.installedAt).toISOString()}`,
       `    source: ${record.source.kind}:${record.source.location} (sha256:${record.source.sha256})`,
-      `    quarantined: ${record.quarantine.required ? `yes — ${record.quarantine.reason ?? 'over-reached its trust tier'}` : 'no'}`,
+      `    quarantined: ${record.quarantine.required ? `yes: ${record.quarantine.reason ?? 'over-reached its trust tier'}` : 'no'}`,
     );
   }
   return { output: formatJsonOrText(runtime, records, lines.join('\n')), exitCode: 0 };

package/src/cli/plugin-command.ts

@@ -8,13 +8,13 @@ import type { CliCommandOutput, CliCommandRuntime } from '@pellux/goodvibes-term
 import { handlePluginBundlesCommand } from './plugin-bundles-command.ts';
 
 // ---------------------------------------------------------------------------
-// `goodvibes plugin init` / `plugin validate` — scaffold and check plugins
+// `goodvibes plugin init` / `plugin validate`, scaffold and check plugins
 // against the SAME classic loader the running TUI uses (PluginManager wraps
 // discoverPlugins from @pellux/goodvibes-sdk/platform/plugins). The pass/fail
 // verdict is the real loader's acceptance: we run discoverPlugins against the
 // target directory (isolated from the operator's own plugin folders) and check
 // whether it accepts the directory. Reasons for a rejected manifest are sourced
-// from the SDK's validateManifestV2 (string|null) plus observable file facts —
+// from the SDK's validateManifestV2 (string|null) plus observable file facts,
 // no second manifest schema is defined here.
 // ---------------------------------------------------------------------------
 
@@ -57,7 +57,7 @@ function validatePluginDirectory(dirPath: string): PluginValidation {
     };
   }
 
-  // Rejected — explain why, delegating field checks to the SDK validator.
+  // Rejected, explain why, delegating field checks to the SDK validator.
   const reasons: string[] = [];
   if (!existsSync(manifestPath)) {
     reasons.push('manifest.json not found in the plugin directory.');
@@ -67,14 +67,14 @@ function validatePluginDirectory(dirPath: string): PluginValidation {
   try {
     manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   } catch (error) {
-    reasons.push(`manifest.json is not valid JSON — ${summarizeError(error)}`);
+    reasons.push(`manifest.json is not valid JSON; ${summarizeError(error)}`);
     return { ok: false, path: resolved, reasons };
   }
   const fieldReason = validateManifestV2(manifest);
   if (fieldReason) {
     reasons.push(fieldReason);
   } else {
-    reasons.push('the plugin loader did not accept this directory — if "main" is set it must be a relative path.');
+    reasons.push('the plugin loader did not accept this directory; if "main" is set it must be a relative path.');
   }
   return { ok: false, path: resolved, reasons };
 }
@@ -85,7 +85,7 @@ function renderValidation(result: PluginValidation, json: boolean): CliCommandOu
   }
   const lines = ['GoodVibes plugin validation', `  path: ${result.path}`];
   if (result.ok) {
-    lines.push(`  PASS  ${result.manifestName} v${result.manifestVersion} — the plugin loader accepts this directory.`);
+    lines.push(`  PASS  ${result.manifestName} v${result.manifestVersion}: the plugin loader accepts this directory.`);
   } else {
     lines.push('  FAIL  the plugin loader rejects this directory:');
     for (const reason of result.reasons) lines.push(`    - ${reason}`);
@@ -135,7 +135,7 @@ function handlePluginInit(runtime: CliCommandRuntime): CliCommandOutput {
     return {
       output: json
         ? JSON.stringify({ ok: false, path: targetDir, reason: summarizeError(error) }, null, 2)
-        : `Failed to scaffold plugin at ${targetDir} — ${summarizeError(error)}`,
+        : `Failed to scaffold plugin at ${targetDir}; ${summarizeError(error)}`,
       exitCode: 1,
     };
   }
@@ -152,8 +152,8 @@ function handlePluginInit(runtime: CliCommandRuntime): CliCommandOutput {
     `Scaffolded plugin "${name}" at ${targetDir}`,
     '  created: manifest.json, index.js',
     validation.ok
-      ? '  validation: PASS — the plugin loader accepts this directory.'
-      : `  validation: FAIL — ${validation.reasons.join('; ')}`,
+      ? '  validation: PASS; the plugin loader accepts this directory.'
+      : `  validation: FAIL; ${validation.reasons.join('; ')}`,
     `  next: run "goodvibes plugin validate ${targetDir}" or restart the TUI to load it.`,
   ];
   return { output: lines.join('\n'), exitCode: validation.ok ? 0 : 1 };

package/src/cli/service-posture.ts

@@ -399,7 +399,7 @@ export async function buildCliServicePosture(
       binding,
       bindPosture: classifyBindPosture(binding),
       networkFacing: isNetworkFacing(enabled, binding),
-      // Never TCP-probe the fallback endpoint of an unrecognized hostMode —
+      // Never TCP-probe the fallback endpoint of an unrecognized hostMode,
       // a probe asserts a binding that does not exist.
       ...(options.probe && enabled && binding.recognized ? { reachable: await probeTcp(binding.host, binding.port) } : {}),
     };

package/src/cli/status.ts

@@ -25,11 +25,11 @@ export interface CliStatusOptions {
   readonly workspace?: CliWorkspaceStatus;
   /** Per-command exec sandbox availability, host-probed by the caller. */
   readonly sandbox?: CliSandboxStatus;
-  /** Outbound relay reachability posture (config + feature-flag gate only — a one-shot CLI process has no live connection to inspect). */
+  /** Outbound relay reachability posture (config + feature-flag gate only, a one-shot CLI process has no live connection to inspect). */
   readonly relay?: CliRelayStatus;
 }
 
-/** Config-derived relay posture. No live socket check — see doctor's other surfaces for the same honesty bar. */
+/** Config-derived relay posture. No live socket check, see doctor's other surfaces for the same honesty bar. */
 export interface CliRelayStatus {
   readonly configEnabled: boolean;
   readonly featureEnabled: boolean;
@@ -138,7 +138,7 @@ export interface CliStatusSnapshot {
 /**
  * Per-surface exposure report row: what a network surface binds to, how it
  * authenticates callers, and what cross-origin allowlist (if any) applies.
- * A plain report — it changes no behavior and writes no config.
+ * A plain report, it changes no behavior and writes no config.
  */
 export interface CliExposureSurface {
   readonly id: RuntimeEndpointId;
@@ -205,7 +205,7 @@ function renderWorkspaceSection(workspace: CliWorkspaceStatus | null): string[]
   ];
 }
 
-/** The `Exec sandbox:` block — honest host-probed availability of the per-command boundary. */
+/** The `Exec sandbox:` block, honest host-probed availability of the per-command boundary. */
 function renderSandboxSection(sandbox: CliSandboxStatus | null): string[] {
   if (!sandbox) return [];
   const active = sandbox.configEnabled && sandbox.featureEnabled && sandbox.available;
@@ -228,7 +228,7 @@ function renderSandboxSection(sandbox: CliSandboxStatus | null): string[] {
 }
 
 /**
- * The `Relay:` block — config + feature-flag gate only. The live registration
+ * The `Relay:` block, config + feature-flag gate only. The live registration
  * state lives in the running daemon's memory and no verb exposes it, so no
  * client reads it: this CLI reports the gate, and `/relay status` in the
  * terminal app reports the same gate plus an honest "not readable here" for the
@@ -245,7 +245,7 @@ function renderRelaySection(relay: CliRelayStatus | null): string[] {
     `  url: ${relay.url || '(not set)'}`,
     `  rendezvousId: ${relay.rendezvousId || '(not yet minted)'}`,
     `  requireStepUpForMutations: ${yesNo(relay.requireStepUpForMutations)}`,
-    '  Threat model: the relay operator sees only ciphertext and connection metadata — self-host your own relay for full control.',
+    '  Threat model: the relay operator sees only ciphertext and connection metadata; self-host your own relay for full control.',
     '',
   ];
 }
@@ -296,7 +296,7 @@ const EXPOSURE_SURFACES: readonly { readonly id: RuntimeEndpointId; readonly lab
 
 /**
  * Build the per-surface exposure report (bind address, auth mode, origin
- * allowlist) for every network surface. Pure over the status options — a
+ * allowlist) for every network surface. Pure over the status options, a
  * report only, no behavior change.
  */
 export function buildCliExposureReport(options: CliStatusOptions): readonly CliExposureSurface[] {
@@ -343,7 +343,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
   const findings: CliDoctorFinding[] = [];
 
   // An unrecognized hostMode has NO binding the SDK can produce (its bind
-  // resolver has no default case — the daemon throws before binding), so it
+  // resolver has no default case, the daemon throws before binding), so it
   // is surfaced as a doctor finding on every endpoint that carries one,
   // instead of the fallback loopback binding being presented as fact.
   for (const [endpointId, endpointLabel, endpointBinding] of [
@@ -535,7 +535,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
 /**
  * The doctor command's exit code. Advisory findings (`severity: 'warning'`)
  * are notes on an otherwise-usable install and must never make a healthy
- * install report failure — only a must-fix (`severity: 'risk'`) finding
+ * install report failure, only a must-fix (`severity: 'risk'`) finding
  * exits non-zero. `strict` (for CI) flips warnings to failures too, so a
  * pipeline can require a fully clean report instead of just "usable".
  */
@@ -666,7 +666,7 @@ export function renderCliStatus(options: CliStatusOptions): string {
     ...renderWorkspaceSection(snapshot.workspace),
     ...renderSandboxSection(snapshot.sandbox),
     ...renderRelaySection(snapshot.relay),
-    'Exposure (report only — no changes made):',
+    'Exposure (report only: no changes made):',
     ...snapshot.exposure.flatMap((surface) => [
       `  ${surface.label}: ${yesNo(surface.enabled)} · ${surface.reach}${surface.networkFacing ? ' · network-facing' : ''}`,
       `    bind: ${surface.bind}`,

package/src/cli/surface-command.ts

@@ -131,7 +131,7 @@ export async function handleSurfacesCommand(runtime: CliCommandRuntime): Promise
   const readinessIssues: string[] = [];
   for (const [endpointLabel, endpointBinding] of [['controlPlane', controlPlane], ['web', web], ['httpListener', httpListener]] as const) {
     if (!endpointBinding.recognized) {
-      readinessIssues.push(`${endpointLabel}.hostMode '${endpointBinding.hostMode}' is not a recognized mode (local|network|custom) — the daemon cannot bind this endpoint until it is corrected.`);
+      readinessIssues.push(`${endpointLabel}.hostMode '${endpointBinding.hostMode}' is not a recognized mode (local|network|custom); the daemon cannot bind this endpoint until it is corrected.`);
     }
   }
   if (shouldProbeControlPlane && controlPlane.recognized && config.get('controlPlane.enabled') === true && !controlPlaneReachable) {
@@ -218,7 +218,7 @@ export interface ListenerTestResult {
   readonly port: number;
   readonly recognized: boolean;
   readonly posture: ReturnType<typeof classifyBindPosture>;
-  /** undefined = NOT PROBED (unrecognized host mode) — a tri-state, never coerced to false. */
+  /** undefined = NOT PROBED (unrecognized host mode), a tri-state, never coerced to false. */
   readonly reachable: boolean | undefined;
   readonly service: {
     readonly enabled: unknown;
@@ -241,7 +241,7 @@ export async function buildListenerTestResult(runtime: CliCommandRuntime): Promi
   const enabled = runtime.configManager.get('danger.httpListener');
   const binding = resolveRuntimeEndpointBinding(runtime.configManager, 'httpListener');
   const posture = classifyBindPosture(binding);
-  // Not-probed (unrecognized host mode) stays undefined — never a definite false.
+  // Not-probed (unrecognized host mode) stays undefined, never a definite false.
   const reachable = enabled === true
     ? (binding.recognized ? await probeTcp(binding.host, binding.port) : undefined)
     : false;
@@ -265,7 +265,7 @@ export async function buildListenerTestResult(runtime: CliCommandRuntime): Promi
     };
   }).filter((surface) => surface.enabled === true);
   const issues: string[] = [];
-  if (!binding.recognized) issues.push(`httpListener.hostMode '${binding.hostMode}' is not a recognized mode (local|network|custom) — the daemon cannot bind until it is corrected.`);
+  if (!binding.recognized) issues.push(`httpListener.hostMode '${binding.hostMode}' is not a recognized mode (local|network|custom); the daemon cannot bind until it is corrected.`);
   if (enabled !== true) issues.push('HTTP listener is disabled.');
   if (enabled === true && service.enabled !== true) issues.push('HTTP listener is enabled but service mode is off.');
   if (enabled === true && service.autostart !== true) issues.push('HTTP listener is enabled but service autostart is off.');