@pellux/goodvibes-tui 1.1.0 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "1.1.0",
+  "version": "1.9.0",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -99,7 +99,7 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "0.36.0",
+    "@pellux/goodvibes-sdk": "1.0.0",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/audio/spoken-turn-controller.ts

@@ -61,7 +61,16 @@ export class SpokenTurnController {
     return true;
   }
 
-  stop(message?: string): void {
+  /**
+   * Returns whether speech was actually ACTIVE when stopped. The notice only
+   * prints in that case — stop() on an idle controller used to notify anyway,
+   * spamming "[TTS] Spoken output stopped." on every Ctrl+C (batch replay
+   * D5/N-noise); callers use the return to decide whether the press "did a
+   * job" (see handleCtrlC's consume-on-speech-stop).
+   */
+  stop(message?: string): boolean {
+    const wasActive = this.pendingPrompt !== null || this.activeTurnId !== null
+      || this.chunker !== null || this.abortControllers.size > 0;
     this.pendingPrompt = null;
     this.activeTurnId = null;
     this.chunker?.reset();
@@ -72,7 +81,8 @@ export class SpokenTurnController {
     this.player.stop();
     this.playbackChain = Promise.resolve();
     this.errorReportedForTurn = false;
-    if (message) this.notify?.(`[TTS] ${message}`);
+    if (message && wasActive) this.notify?.(`[TTS] ${message}`);
+    return wasActive;
   }
 
   handleTurnEvent(event: TurnEvent): void {

package/src/audio/spoken-turn-wiring.ts

@@ -8,7 +8,8 @@ import { SpokenTurnController } from './spoken-turn-controller.ts';
 export interface SpokenTurnRuntime {
   readonly unsubs: readonly (() => void)[];
   submitNextTurn(prompt: string): boolean;
-  stop(message?: string): void;
+  /** Returns whether speech was actually active (see controller.stop). */
+  stop(message?: string): boolean;
 }
 
 export interface WireSpokenTurnRuntimeOptions {

package/src/cli/help.ts

@@ -283,10 +283,17 @@ export function renderGoodVibesCommandHelp(topic: string, binary = 'goodvibes'):
 
 export function renderGoodVibesDaemonHelp(binary = 'goodvibes-daemon'): string {
   return [
-    `Usage: ${binary} [OPTIONS]`,
+    `Usage: ${binary} [COMMAND] [OPTIONS]`,
     '',
     'Starts the headless GoodVibes daemon/API host.',
     '',
+    'Commands:',
+    '  install-service                Install + enable the daemon as a systemd user service (survives reboots)',
+    '  uninstall-service              Disable + remove the daemon systemd user service',
+    '  service-status                 Show whether the daemon service is installed / enabled / active',
+    '  migrate-service                Guided takeover of a legacy goodvibes-daemon.service unit; prints a plan',
+    '                                 unless run with -y/--yes (never auto-migrates)',
+    '',
     'Options:',
     '      --daemon-home <dir>        Override daemon home',
     '      --working-dir <dir>        Override working directory',

package/src/cli/service-posture.ts

@@ -5,6 +5,7 @@ import { basename, delimiter, dirname, isAbsolute, join, resolve } from 'node:pa
 import { fileURLToPath } from 'node:url';
 import { PlatformServiceManager } from '@pellux/goodvibes-sdk/platform/daemon';
 import type { ManagedServiceStatus } from '@pellux/goodvibes-sdk/platform/daemon';
+import { resolveDaemonEnabled } from '@pellux/goodvibes-sdk/platform/config';
 import type { ConfigManager } from '../config/index.ts';
 import { resolveRuntimeEndpointBinding } from './endpoints.ts';
 import type { RuntimeEndpointBinding, RuntimeEndpointId } from './endpoints.ts';
@@ -392,7 +393,7 @@ export async function buildCliServicePosture(
     enabled: runtime.configManager.get('service.enabled') === true,
     autostart: runtime.configManager.get('service.autostart') === true,
     restartOnFailure: runtime.configManager.get('service.restartOnFailure') === true,
-    daemonEnabled: runtime.configManager.get('danger.daemon') === true,
+    daemonEnabled: resolveDaemonEnabled(runtime.configManager),
   };
   const serverBackedEnabled = config.daemonEnabled || endpoints.some((endpoint) => endpoint.enabled);
   const issues: string[] = [];

package/src/cli/status.ts

@@ -1,4 +1,5 @@
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { resolveDaemonEnabled } from '@pellux/goodvibes-sdk/platform/config';
 import type { OnboardingCheckMarkersState } from '../runtime/onboarding/index.ts';
 import { resolveRuntimeEndpointBinding } from './endpoints.ts';
 import { isNetworkFacing } from './network-posture.ts';
@@ -98,7 +99,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
   const serviceEnabled = config.get('service.enabled') === true;
   const serviceAutostart = config.get('service.autostart') === true;
   const restartOnFailure = config.get('service.restartOnFailure') === true;
-  const daemonEnabled = config.get('danger.daemon') === true;
+  const daemonEnabled = resolveDaemonEnabled(config);
   const listenerEnabled = config.get('danger.httpListener') === true;
   const webEnabled = config.get('web.enabled') === true;
   const controlPlaneEnabled = config.get('controlPlane.enabled') === true;

package/src/cli/surface-command.ts

@@ -47,7 +47,7 @@ export async function handleSurfacesCommand(runtime: CliCommandRuntime): Promise
       runtime.configManager.setDynamic('web.enabled', enabled);
       if (enabled) {
         enableFeatureFlags(runtime.configManager, getServerSurfaceFeatureFlags({ serverBacked: true, web: true }));
-        runtime.configManager.setDynamic('danger.daemon', true);
+        runtime.configManager.setDynamic('daemon.enabled', true);
         runtime.configManager.setDynamic('controlPlane.enabled', true);
         const webError = applyTargetEndpointFlagsOrDefault(runtime, 'web');
         if (webError) return { output: webError, exitCode: 2 };
@@ -70,7 +70,7 @@ export async function handleSurfacesCommand(runtime: CliCommandRuntime): Promise
     }
     else if (target === 'control-plane' || target === 'controlPlane') {
       runtime.configManager.setDynamic('controlPlane.enabled', enabled);
-      runtime.configManager.setDynamic('danger.daemon', enabled);
+      runtime.configManager.setDynamic('daemon.enabled', enabled);
       if (enabled) {
         const controlPlaneError = applyTargetEndpointFlagsOrDefault(runtime, 'controlPlane');
         if (controlPlaneError) return { output: controlPlaneError, exitCode: 2 };

package/src/core/alert-gating.ts

@@ -0,0 +1,67 @@
+/**
+ * alert-gating — shared config + focus gating logic for the unfocused-user
+ * alert classes (budget-breach, long-task, agent/chain failure,
+ * awaiting-approval). Each alert class has its own on/off config key
+ * (default true); a single master key, `behavior.notifyOnlyWhenUnfocused`
+ * (default true), decides whether any of them additionally require the
+ * terminal to be unfocused-or-unknown before firing.
+ *
+ * Extracted so every alert-class module (long-task-notifier.ts,
+ * budget-breach-notifier.ts, approval-alert.ts, and the agent/chain-failure
+ * wiring in turn-event-wiring.ts) shares one implementation of "should this
+ * fire right now" instead of re-deriving the same two config reads and the
+ * same focus check.
+ */
+import type { FocusTracker } from './focus-tracker.ts';
+
+/** Minimal config-read surface every gating check needs. */
+export type ConfigGet = (key: string) => unknown;
+
+/** Read a TUI-local synthetic boolean setting, defaulting when absent/invalid. */
+export function readBooleanConfig(configGet: ConfigGet, key: string, defaultValue: boolean): boolean {
+  const raw = configGet(key);
+  if (typeof raw === 'boolean') return raw;
+  if (raw === undefined || raw === null) return defaultValue;
+  // Tolerate string/number forms the same way the rest of the config layer does
+  // (settings-modal writes real booleans, but env/file edits may not).
+  if (raw === 'true' || raw === 1) return true;
+  if (raw === 'false' || raw === 0) return false;
+  return defaultValue;
+}
+
+/** `behavior.notifyOnlyWhenUnfocused` — master gate, default on. */
+export function readNotifyOnlyWhenUnfocused(configGet: ConfigGet): boolean {
+  return readBooleanConfig(configGet, 'behavior.notifyOnlyWhenUnfocused', true);
+}
+
+/**
+ * Decide whether a given alert class should fire right now.
+ *
+ * `classConfigKey` is the per-class on/off switch (e.g.
+ * 'behavior.notifyOnBudgetBreach'); default true when absent. When that key
+ * is off, the class never fires regardless of focus. When it's on, the
+ * result additionally depends on the master `notifyOnlyWhenUnfocused` gate:
+ * if that master gate is off, the class fires unconditionally (today's
+ * pre-focus-tracking behavior); if on (the default), it only fires when the
+ * terminal is unfocused or focus state was never observed (see
+ * FocusTracker.shouldAlertWhenUnfocused).
+ */
+export function shouldFireAlert(
+  focusTracker: Pick<FocusTracker, 'shouldAlertWhenUnfocused'>,
+  configGet: ConfigGet,
+  classConfigKey: string,
+): boolean {
+  if (!readBooleanConfig(configGet, classConfigKey, true)) return false;
+  if (!readNotifyOnlyWhenUnfocused(configGet)) return true;
+  return focusTracker.shouldAlertWhenUnfocused();
+}
+
+/**
+ * notifyCompletion (SDK platform/utils) only rings the bell above 5s of
+ * "duration" and only pops a desktop notification above 30s — a heuristic
+ * tuned for long-running-turn notifications. The alert classes in this
+ * directory are point-in-time events with no natural duration, so they pass
+ * this constant as the `durationMs` argument to force both the bell and the
+ * desktop popup unconditionally.
+ */
+export const FORCE_NOTIFY_DURATION_MS = 30_001;

package/src/core/approval-alert.ts

@@ -0,0 +1,72 @@
+/**
+ * approval-alert — fires an unfocused-user alert the moment a tool call
+ * becomes a real, user-blocking permission prompt.
+ *
+ * Anchor: `PERMISSION_REQUESTED` (SDK events/permissions.ts) is the wrong
+ * signal — it fires for every policy-evaluation step, including ones
+ * auto-resolved by allow-lists/yolo-mode in milliseconds. The only place a
+ * request becomes an actual user-facing prompt is where main.ts assigns
+ * `permissionPromptRef.requestPermission`. There is no `permissions` feed on
+ * UiRuntimeEvents to subscribe to instead, so this wraps the handler at that
+ * assignment site.
+ *
+ * wrapRequestPermissionWithAlert fires the alert synchronously (before the
+ * wrapped promise settles) so it reflects "a prompt just appeared", not
+ * "a prompt was just resolved".
+ *
+ * PRIVACY: message content is tool name + permission category only — no
+ * args, no file contents, no command strings (mirrors long-task-notifier's
+ * privacy guarantee).
+ */
+import { notifyCompletion } from '@pellux/goodvibes-sdk/platform/utils';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import type { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
+import type { PermissionRequestHandler, PermissionPromptRequest } from '@pellux/goodvibes-sdk/platform/permissions';
+import type { FocusTracker } from './focus-tracker.ts';
+import { shouldFireAlert, FORCE_NOTIFY_DURATION_MS, type ConfigGet } from './alert-gating.ts';
+
+export interface ApprovalAlertDeps {
+  readonly focusTracker: Pick<FocusTracker, 'shouldAlertWhenUnfocused'>;
+  readonly configGet: ConfigGet;
+  readonly webhookNotifier?: WebhookNotifier | null;
+}
+
+/**
+ * Wrap a PermissionRequestHandler so every call also fires an unfocused-user
+ * alert (subject to the behavior.notifyOnApprovalPending / notifyOnlyWhenUnfocused
+ * gates). The wrapped handler's behavior (what it resolves to) is completely
+ * unchanged — this only adds a side effect at call time.
+ */
+export function wrapRequestPermissionWithAlert(
+  original: PermissionRequestHandler,
+  deps: ApprovalAlertDeps,
+): PermissionRequestHandler {
+  return (request: PermissionPromptRequest) => {
+    fireApprovalAlert(request, deps);
+    return original(request);
+  };
+}
+
+function fireApprovalAlert(request: PermissionPromptRequest, deps: ApprovalAlertDeps): void {
+  if (!shouldFireAlert(deps.focusTracker, deps.configGet, 'behavior.notifyOnApprovalPending')) return;
+
+  const title = 'GoodVibes — approval needed';
+  // PRIVACY: tool name + category only. Never request.args.
+  const message = `${request.tool} (${request.category}) is waiting for approval`;
+
+  try {
+    notifyCompletion(title, message, FORCE_NOTIFY_DURATION_MS);
+  } catch (err) {
+    logger.debug('approval-alert: desktop notify error', { error: String(err) });
+  }
+
+  const webhookNotifier = deps.webhookNotifier;
+  if (webhookNotifier) {
+    const urls = webhookNotifier.getUrls();
+    if (urls.length > 0) {
+      webhookNotifier.send(message).catch((err: unknown) => {
+        logger.debug('approval-alert: webhook send error', { error: String(err) });
+      });
+    }
+  }
+}

package/src/core/budget-breach-notifier.ts

@@ -0,0 +1,106 @@
+/**
+ * budget-breach-notifier — fires an unfocused-user alert the moment session
+ * cost crosses the configured budget threshold (behavior.budgetAlertUsd).
+ *
+ * One-shot semantics: fires exactly once on the false→true edge (crossing
+ * into breach), never again while still over budget on every subsequent
+ * turn. The "already notified" latch resets when the session drops back
+ * under budget (so a later re-breach can fire again) or when the threshold
+ * itself changes (raising, lowering, or clearing the budget re-arms it
+ * against the new value).
+ *
+ * Delivery mirrors long-task-notifier.ts: desktop notification
+ * (notifyCompletion) + outbound webhook (WebhookNotifier), both gated by
+ * the shared focus/config gating in alert-gating.ts. Skips evaluation
+ * entirely when the session model is unpriced — a $0 placeholder cost must
+ * never be reported as a real breach (mirrors CostTrackerPanel's "unpriced"
+ * display convention).
+ *
+ * PRIVACY: message text is built from cost/threshold numbers and the
+ * session id prefix only — no conversation content.
+ */
+import { notifyCompletion } from '@pellux/goodvibes-sdk/platform/utils';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import type { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
+import { calcSessionCost, computeBudgetBreach, isModelPriced } from '../export/cost-utils.ts';
+import type { FocusTracker } from './focus-tracker.ts';
+import { shouldFireAlert, FORCE_NOTIFY_DURATION_MS, type ConfigGet } from './alert-gating.ts';
+
+export interface BudgetBreachUsageSnapshot {
+  readonly input: number;
+  readonly output: number;
+  readonly cacheRead: number;
+  readonly cacheWrite: number;
+}
+
+export interface BudgetBreachNotifierDeps {
+  readonly focusTracker: Pick<FocusTracker, 'shouldAlertWhenUnfocused'>;
+  readonly configGet: ConfigGet;
+  readonly webhookNotifier?: WebhookNotifier | null;
+  readonly sessionId: string;
+}
+
+/** Stateful edge-trigger checker — construct once per session, call on every TURN_COMPLETED. */
+export interface BudgetBreachNotifier {
+  /**
+   * Evaluate current usage against the configured threshold and fire an
+   * alert on the false→true breach edge. Returns true when an alert was
+   * fired this call (for tests / observability), false otherwise.
+   */
+  check(usage: BudgetBreachUsageSnapshot, sessionModel: string, budgetThresholdUsd: number): boolean;
+}
+
+export function createBudgetBreachNotifier(deps: BudgetBreachNotifierDeps): BudgetBreachNotifier {
+  let lastThreshold: number | null = null;
+  let notified = false;
+
+  return {
+    check(usage, sessionModel, budgetThresholdUsd) {
+      if (budgetThresholdUsd !== lastThreshold) {
+        // Threshold raised, lowered, or cleared since the last check — re-arm
+        // the latch so a breach against the new threshold can fire again.
+        lastThreshold = budgetThresholdUsd;
+        notified = false;
+      }
+
+      if (budgetThresholdUsd <= 0) return false; // disabled
+      if (!isModelPriced(sessionModel)) return false; // cost would be a placeholder, not real
+
+      const sessionCost = calcSessionCost(usage.input, usage.output, usage.cacheRead, usage.cacheWrite, sessionModel);
+      const breached = computeBudgetBreach(sessionCost, budgetThresholdUsd);
+
+      if (!breached) {
+        notified = false; // dropped back under budget — can re-fire on the next crossing
+        return false;
+      }
+      if (notified) return false; // already alerted for this crossing
+
+      notified = true;
+      fireBudgetBreachAlert(deps, sessionCost, budgetThresholdUsd);
+      return true;
+    },
+  };
+}
+
+function fireBudgetBreachAlert(deps: BudgetBreachNotifierDeps, sessionCost: number, budgetThresholdUsd: number): void {
+  if (!shouldFireAlert(deps.focusTracker, deps.configGet, 'behavior.notifyOnBudgetBreach')) return;
+
+  const title = 'GoodVibes — budget breach';
+  const message = `session cost $${sessionCost.toFixed(2)} exceeded budget $${budgetThresholdUsd.toFixed(2)}  ·  session ${deps.sessionId.slice(0, 8)}`;
+
+  try {
+    notifyCompletion(title, message, FORCE_NOTIFY_DURATION_MS);
+  } catch (err) {
+    logger.debug('budget-breach-notifier: desktop notify error', { error: String(err) });
+  }
+
+  const webhookNotifier = deps.webhookNotifier;
+  if (webhookNotifier) {
+    const urls = webhookNotifier.getUrls();
+    if (urls.length > 0) {
+      webhookNotifier.send(message).catch((err: unknown) => {
+        logger.debug('budget-breach-notifier: webhook send error', { error: String(err) });
+      });
+    }
+  }
+}

package/src/core/composer-state.ts

@@ -20,8 +20,13 @@ export function deriveComposerState(input: ComposerStateInput): ComposerState {
   const flags: string[] = [];
   let pendingRisk: ComposerState['pendingRisk'] = 'none';
 
-  if (input.pendingApproval) {
-    flags.push('approval');
+  // An approval wait is the dominant composer state and owns the single honest
+  // status tag: `risk:approval-wait`. It is therefore NOT also duplicated as a
+  // `approval` flag, and (below) it suppresses the competing `state:` turn tag —
+  // the turn is blocked on the user, not really streaming. Precedence:
+  // approval-wait > live turn state. (UX-B item 4.)
+  const approvalWait = input.pendingApproval === true;
+  if (approvalWait) {
     pendingRisk = 'approval-wait';
   }
   if (intent.kind === 'shell') {
@@ -35,7 +40,7 @@ export function deriveComposerState(input: ComposerStateInput): ComposerState {
   }
   if (input.hasAttachments) flags.push('attachments');
 
-  const statusLabel = (() => {
+  const turnStatus = (() => {
     switch (input.turnState) {
       case 'preflight': return 'preflight';
       case 'streaming': return 'streaming';
@@ -47,6 +52,9 @@ export function deriveComposerState(input: ComposerStateInput): ComposerState {
       default: return 'idle';
     }
   })();
+  // 'idle' is suppressed by the footer renderer, so an approval wait shows only
+  // `risk:approval-wait` — one honest tag, not three spellings of the wait.
+  const statusLabel = approvalWait ? 'idle' : turnStatus;
 
   return {
     intent,

package/src/core/conversation-line-cache.ts

@@ -49,6 +49,7 @@ import {
   renderConversationSystemMessage,
   renderConversationToolMessage,
   renderConversationUserMessage,
+  collectCompletedToolCallIds,
 } from './conversation-rendering.ts';
 import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
 // SystemMessageKind imported from runtime directly to avoid a cycle, mirroring
@@ -94,6 +95,18 @@ interface KeyMeta {
   readonly showReasoningSummary: boolean;
   readonly blockBase: number;
   readonly kind: SystemMessageKind | undefined;
+  /**
+   * True when this (assistant) message has a tool call with no result yet — it
+   * renders as pending rather than done. Keyed so the entry invalidates and
+   * re-renders ✓ once the tool result arrives. (UX-B item 2c.)
+   */
+  readonly hasPendingTool: boolean;
+}
+
+/** Whether an assistant message has any tool call still awaiting a result. */
+function hasPendingToolCall(m: Message, completed: ReadonlySet<string>): boolean {
+  if (m.role !== 'assistant' || !m.toolCalls) return false;
+  return m.toolCalls.some((tc) => tc.id === undefined || !completed.has(tc.id));
 }
 
 interface CacheEntry {
@@ -272,6 +285,11 @@ export class MessageLineCache {
       showReasoningSummary: context.configManager?.get('display.showReasoningSummary') ?? false,
     };
 
+    // Tool calls with no matching tool-result message are still pending; the
+    // render context and the cache key both depend on this. (UX-B item 2c.)
+    const completedToolCallIds = collectCompletedToolCallIds(messages);
+    const renderContext: ConversationRenderContext = { ...context, completedToolCallIds };
+
     const touched = new Set<number>();
 
     for (let i = 0; i < messages.length; i++) {
@@ -283,17 +301,18 @@ export class MessageLineCache {
 
       const uncacheable = absoluteIdx === streamingPlaceholderAbsIdx;
       const kind = context.messageKindRegistry.get(absoluteIdx);
+      const hasPendingTool = hasPendingToolCall(message, completedToolCallIds);
 
       if (!uncacheable) {
         const existing = this.entries.get(absoluteIdx);
-        if (existing && this.isValid(existing, message, width, cfg, blockBase, kind, context.collapseState)) {
+        if (existing && this.isValid(existing, message, width, cfg, blockBase, kind, hasPendingTool, context.collapseState)) {
           this.applyEntry(context, existing, base);
           touched.add(absoluteIdx);
           continue;
         }
       }
 
-      const entry = this.renderScratch(context, message, width, absoluteIdx, cfg, blockBase, kind);
+      const entry = this.renderScratch(renderContext, message, width, absoluteIdx, cfg, blockBase, kind, hasPendingTool);
       this.applyEntry(context, entry, base);
       if (!uncacheable) {
         this.entries.set(absoluteIdx, entry);
@@ -319,6 +338,7 @@ export class MessageLineCache {
     cfg: RenderConfig,
     blockBase: number,
     kind: SystemMessageKind | undefined,
+    hasPendingTool: boolean,
     collapseState: Map<string, boolean>,
   ): boolean {
     const k = entry.keyMeta;
@@ -330,7 +350,8 @@ export class MessageLineCache {
       k.showThinking !== cfg.showThinking ||
       k.showReasoningSummary !== cfg.showReasoningSummary ||
       k.blockBase !== blockBase ||
-      k.kind !== kind
+      k.kind !== kind ||
+      k.hasPendingTool !== hasPendingTool
     ) {
       return false;
     }
@@ -355,6 +376,7 @@ export class MessageLineCache {
     cfg: RenderConfig,
     blockBase: number,
     kind: SystemMessageKind | undefined,
+    hasPendingTool: boolean,
   ): CacheEntry {
     const scratchLines: Line[] = [];
     const scratchHistory = {
@@ -378,6 +400,7 @@ export class MessageLineCache {
       messageKindRegistry: context.messageKindRegistry,
       configManager: context.configManager,
       splashOptions: context.splashOptions,
+      completedToolCallIds: context.completedToolCallIds,
     };
 
     renderOne(scratchCtx, message, width, absoluteIdx, cfg);
@@ -397,6 +420,7 @@ export class MessageLineCache {
         showReasoningSummary: cfg.showReasoningSummary,
         blockBase,
         kind,
+        hasPendingTool,
       },
       contentSig: contentSigOf(message),
       lines: scratchLines,