@pellux/goodvibes-tui 1.21.0 → 1.22.0

package/src/verification/verification-ledger.ts

@@ -79,6 +79,116 @@ export const FEATURE_KNOB_LOCAL_SETTINGS = [
   'runtime.toolBudget.maxCostUsd',
 ] as const;
 
+/**
+ * Config keys added by the paired-device and trigger-family domains in SDK
+ * 1.14.0. Like FEATURE_KNOB_LOCAL_SETTINGS above, these arrived as new
+ * CONFIG_SCHEMA entries that raised the settings inventory `total` with no
+ * matching behavior coverage, dropping `localBehaviorPercent` below its floor.
+ *
+ * THIS CONSTANT IS NOT A DIAL. Each key below is counted because a test that
+ * exercises it was actually written:
+ * `src/test/verification/device-and-trigger-settings-persistence.test.ts` runs,
+ * for every key in this list, the same four-part persistence contract the
+ * feature-knob keys are counted for — schema default exposure, `set()` through
+ * the key's own validator to disk, reload into a fresh ConfigManager with
+ * read-back equality, and reset-to-default that also survives reload. That test
+ * additionally asserts this list is exactly the non-enablement key set of both
+ * domains and overlaps neither of the other counted sets, so nothing here is
+ * double-counted and nothing drifts in uncounted.
+ *
+ * PER-KEY EVIDENCE — what is verified, and how live the key is TODAY.
+ * "persistence" below means the four-part contract above; the second column
+ * records whether anything in this tree (TUI or the pinned SDK) reads the key,
+ * audited by tracing each key to its consumers.
+ *
+ *   watchers.triggers.backoffLadderMs        persistence · live (trigger supervisor retry ladder)
+ *   watchers.triggers.breakerStrikes         persistence · live (strike breaker)
+ *   watchers.triggers.defaultCheckIntervalMs persistence · live (condition-check scheduler)
+ *   watchers.triggers.probeTimeoutMs         persistence · live (probe execution)
+ *   watchers.triggers.maxConcurrentChecks    persistence · live (check concurrency cap)
+ *   watchers.triggers.observationRingSize    persistence · live (observation ring)
+ *   watchers.triggers.runHistoryLimit        persistence · live (run history retention)
+ *   watchers.triggers.runHistoryTtlHours     persistence · live (run history sweep)
+ *   watchers.triggers.eventLogLimit          persistence · live (event log retention)
+ *   watchers.triggers.eventLogTtlHours       persistence · live (event log sweep)
+ *   watchers.triggers.sweepIntervalMs        persistence · live (housekeeping cadence)
+ *   watchers.triggers.supervisionTickMs      persistence · live (supervision loop tick)
+ *   watchers.triggers.streamQueueLimit       persistence · live (stream watcher queue)
+ *   watchers.triggers.streamBatchLines       persistence · live (stream batching)
+ *   watchers.triggers.streamBatchIntervalMs  persistence · live (stream batching)
+ *   watchers.triggers.onExitMaxDurationMs    persistence · live (on-exit trigger duration cap)
+ *   watchers.triggers.onExitStdin            persistence · live (on-exit stdin posture)
+ *   watchers.triggers.outputTailBytes        persistence · live (captured output tail)
+ *   device.capabilities.allowAlwaysOffer     persistence · settings surface only in this build
+ *   device.capabilities.requestTimeoutSeconds persistence · settings surface only in this build
+ *   device.location.precision                persistence · settings surface only in this build
+ *   device.clipboard.readMode                persistence · settings surface only in this build
+ *   device.capture.retentionHours            persistence · settings surface only in this build
+ *   device.capture.maxArtifacts              persistence · settings surface only in this build
+ *   device.capture.sweepIntervalMinutes      persistence · settings surface only in this build
+ *   device.grants.expiryDays                 persistence · settings surface only in this build
+ *   device.grants.maxPerNode                 persistence · settings surface only in this build
+ *   device.grants.auditRetentionDays         persistence · settings surface only in this build
+ *   device.nodes.maxPaired                   persistence · live (enforced at the pairing path)
+ *
+ * On `device.nodes.maxPaired`: the SDK enforces it where a device pairs —
+ * PairingTokenManager.mint refuses a NEW node at the cap with
+ * PairingLimitReachedError (code DEVICE_NODES_MAX_PAIRED, carrying the setting
+ * name, the cap and the live count), mapped to HTTP 409 by the pairing and
+ * pairing-handoff routes. An already-paired node supersedes its own record
+ * instead of being refused, migration mints off the legacy shared token are
+ * deliberately exempt, lowering the cap unpairs nobody, and a non-positive or
+ * non-finite value reads as no cap so a broken setting cannot lock the owner
+ * out. The cap is read per mint, so a change applies without a restart. What is
+ * counted HERE is still only the persistence contract this repo's test
+ * exercises — the enforcement itself is SDK-side and SDK-tested, and is recorded
+ * in this column so the "how live is it" audit stays accurate, not to claim
+ * coverage this repo did not write.
+ *
+ * On the other ten `device.*` rows: DeviceCapabilityService carries its own
+ * policy struct whose defaults match those keys one for one, and names them in
+ * its field comments and refusal messages, but no code path in either tree maps
+ * configuration into that struct. Persistence is therefore the whole of what is
+ * verified for them, and the settings-workspace description for the `device`
+ * category says exactly that to the user rather than implying live knobs.
+ *
+ * DELIBERATELY NOT COUNTED: the 24 non-enablement `voice.wake.*` keys from the
+ * same release. `wake-word-detection` is declared `notOperable` — no surface
+ * captures audio — so its rows stay in `total` and out of the numerator. That is
+ * the honest reading, and it is why this list raises coverage by 29 and not 53.
+ */
+export const DEVICE_AND_TRIGGER_LOCAL_SETTINGS = [
+  'watchers.triggers.backoffLadderMs',
+  'watchers.triggers.breakerStrikes',
+  'watchers.triggers.defaultCheckIntervalMs',
+  'watchers.triggers.probeTimeoutMs',
+  'watchers.triggers.maxConcurrentChecks',
+  'watchers.triggers.observationRingSize',
+  'watchers.triggers.runHistoryLimit',
+  'watchers.triggers.runHistoryTtlHours',
+  'watchers.triggers.eventLogLimit',
+  'watchers.triggers.eventLogTtlHours',
+  'watchers.triggers.sweepIntervalMs',
+  'watchers.triggers.supervisionTickMs',
+  'watchers.triggers.streamQueueLimit',
+  'watchers.triggers.streamBatchLines',
+  'watchers.triggers.streamBatchIntervalMs',
+  'watchers.triggers.onExitMaxDurationMs',
+  'watchers.triggers.onExitStdin',
+  'watchers.triggers.outputTailBytes',
+  'device.capabilities.allowAlwaysOffer',
+  'device.capabilities.requestTimeoutSeconds',
+  'device.location.precision',
+  'device.clipboard.readMode',
+  'device.capture.retentionHours',
+  'device.capture.maxArtifacts',
+  'device.capture.sweepIntervalMinutes',
+  'device.grants.expiryDays',
+  'device.grants.maxPerNode',
+  'device.grants.auditRetentionDays',
+  'device.nodes.maxPaired',
+] as const;
+
 /**
  * Every feature's enablement settings key whose on/off writes round-trip
  * through a REAL on-disk ConfigManager in
@@ -95,8 +205,11 @@ const ENABLEMENT_KEYS_BEHAVIOR_VERIFIED = new Set(
     .filter((key) => !(FEATURE_KNOB_LOCAL_SETTINGS as readonly string[]).includes(key)),
 ).size;
 
-/** Settings with real local behavior verification: the authored baseline plus the persistence-tested feature-knob and enablement keys. */
-const SETTINGS_BEHAVIOR_VERIFIED = SETTINGS_BEHAVIOR_BASELINE + FEATURE_KNOB_LOCAL_SETTINGS.length + ENABLEMENT_KEYS_BEHAVIOR_VERIFIED;
+/** Settings with real local behavior verification: the authored baseline plus the persistence-tested feature-knob, device/trigger, and enablement keys. */
+const SETTINGS_BEHAVIOR_VERIFIED = SETTINGS_BEHAVIOR_BASELINE
+  + FEATURE_KNOB_LOCAL_SETTINGS.length
+  + DEVICE_AND_TRIGGER_LOCAL_SETTINGS.length
+  + ENABLEMENT_KEYS_BEHAVIOR_VERIFIED;
 
 const EXTERNAL_SLASH_COMMANDS = new Set([
   'auth',

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '1.21.0';
+let _version = '1.22.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   // Only trust a version read from OUR OWN package.json. A Bun single-file

package/src/core/conversation-tool-groups.ts

@@ -1,152 +0,0 @@
-/**
- * conversation-tool-groups.ts — detects runs of consecutive tool-result
- * messages that belong to one assistant turn, so the transcript can fold them
- * under a single collapsible group header instead of rendering one
- * "tool result" header per call. Before this module, an assistant turn with
- * N tool calls produced N independent header+body blocks in a row — visual
- * spam once N is more than one or two.
- *
- * A run only counts as a group when it has >= 2 matched tool-result messages:
- * a single result renders exactly as it always has (see
- * renderConversationToolMessage in conversation-rendering.ts, which only
- * consults this module's output when a membership entry exists).
- *
- * Pure function of the message slice — no rendering, no width, no side
- * effects. Called once per render pass (appendConversationMessages /
- * MessageLineCache.renderInto) over the currently-visible message slice, with
- * the absolute index of the slice's first message so group keys and member
- * indexes line up with the same collapseKey / blockRegistry indices a cold
- * render would produce (messages may be a post-clearDisplay slice, not the
- * full snapshot — see appendConversationMessages's msgIndexOffset doc).
- */
-
-import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
-import { renderExpandedToolResultLines } from '../renderer/tool-result-expanded-lines.ts';
-
-type Message = ConversationMessageSnapshot;
-
-/** One consolidated run of tool-result messages sharing one assistant turn. */
-export interface ToolGroup {
-  /** Absolute index of the assistant message that owns this group. */
-  readonly assistantIdx: number;
-  /** Absolute indexes of the matched tool-result messages, in order. */
-  readonly toolMessageIndexes: readonly number[];
-}
-
-/**
- * Per-tool-message membership, keyed by the ABSOLUTE index of the tool-result
- * message (the owning assistant message is never a key — only its tool-result
- * children are). `isFirst` marks the member whose render site owns the
- * group's header line and BlockMeta; every other member renders nothing while
- * the group is collapsed (see renderConversationToolMessage).
- */
-export interface ToolGroupMembership {
-  readonly groupKey: string;
-  readonly isFirst: boolean;
-  /** Matched tool-result messages in the group (the header's "N tools"). */
-  readonly toolCount: number;
-  /** Sum of each member's EXPANDED render line count (the header's "N lines") —
-   *  the same post-render count each member's own "N lines" badge shows, so
-   *  the group total matches what expanding every member actually reveals,
-   *  not a raw-content estimate (a folded JSON result can pretty-print to far
-   *  more lines than its raw content has). */
-  readonly totalLines: number;
-  /** Each member's tool name, in order (falls back to 'tool' when a result
-   *  carries no name) — the header dedupes these into e.g. "read×3 exec". */
-  readonly toolNames: readonly string[];
-  /**
-   * Absolute indexes of every tool-result message in the group, in order —
-   * the same list for every member. Carried onto the group's BlockMeta so a
-   * single expand pass can also open each member's own collapse key
-   * (`msg_<idx>`), since a folded member pushes no BlockMeta of its own to
-   * toggle individually (see local-runtime.ts's toggleBlocks).
-   */
-  readonly memberIndexes: readonly number[];
-}
-
-/**
- * Scan `messages` for assistant-message runs of >=2 consecutive matching
- * tool-result messages. A run breaks on the first message that isn't a
- * matching tool result: any non-tool message (interleaved user/system/
- * assistant content), or a tool message whose callId isn't one of the
- * assistant's own toolCalls ids (a result belonging to a different turn never
- * gets folded into a group it doesn't belong to).
- */
-export function detectToolGroups(
-  messages: readonly Message[],
-  indexOffset = 0,
-): ToolGroup[] {
-  const groups: ToolGroup[] = [];
-
-  for (let i = 0; i < messages.length; i++) {
-    const message = messages[i];
-    if (message.role !== 'assistant' || !message.toolCalls || message.toolCalls.length === 0) continue;
-    const callIds = new Set(
-      message.toolCalls
-        .map((tc) => tc.id)
-        .filter((id): id is string => id !== undefined),
-    );
-    if (callIds.size === 0) continue;
-
-    const toolMessageIndexes: number[] = [];
-    let j = i + 1;
-    while (j < messages.length) {
-      const next = messages[j];
-      if (next.role !== 'tool' || !next.callId || !callIds.has(next.callId)) break;
-      toolMessageIndexes.push(indexOffset + j);
-      j++;
-    }
-
-    if (toolMessageIndexes.length >= 2) {
-      groups.push({ assistantIdx: indexOffset + i, toolMessageIndexes });
-    }
-  }
-
-  return groups;
-}
-
-/** Build the per-tool-message membership lookup used by the renderer/cache.
- *  `width` must match the width the transcript is actually rendered at — it
- *  feeds the same expanded-render line count each member's own badge uses
- *  (see renderExpandedToolResultLines), so the group total is never computed
- *  against a different width than what the member badges show. */
-export function buildToolGroupMembership(
-  groups: readonly ToolGroup[],
-  messages: readonly Message[],
-  indexOffset: number,
-  width: number,
-): ReadonlyMap<number, ToolGroupMembership> {
-  const membership = new Map<number, ToolGroupMembership>();
-  for (const group of groups) {
-    const groupKey = `group_${group.assistantIdx}`;
-    let totalLines = 0;
-    const toolNames: string[] = [];
-    for (const absIdx of group.toolMessageIndexes) {
-      const message = messages[absIdx - indexOffset];
-      if (message && message.role === 'tool') {
-        totalLines += renderExpandedToolResultLines(message.content, width).length;
-        toolNames.push(message.toolName ?? 'tool');
-      }
-    }
-    group.toolMessageIndexes.forEach((absIdx, idx) => {
-      membership.set(absIdx, {
-        groupKey,
-        isFirst: idx === 0,
-        toolCount: group.toolMessageIndexes.length,
-        totalLines,
-        toolNames,
-        memberIndexes: group.toolMessageIndexes,
-      });
-    });
-  }
-  return membership;
-}
-
-/** Convenience wrapper: detect groups, then build the membership map in one call. */
-export function computeToolGroupMembership(
-  messages: readonly Message[],
-  indexOffset = 0,
-  width = 80,
-): ReadonlyMap<number, ToolGroupMembership> {
-  return buildToolGroupMembership(detectToolGroups(messages, indexOffset), messages, indexOffset, width);
-}