@pellux/goodvibes-agent 1.5.5 → 1.5.6

package/src/renderer/ui-primitives.ts

@@ -1,96 +1,36 @@
-export const GLYPHS = {
-  frame: {
-    topLeft: '┌',
-    topRight: '┐',
-    bottomLeft: '└',
-    bottomRight: '┘',
-    horizontal: '─',
-    vertical: '│',
-    teeLeft: '├',
-    teeRight: '┤',
-    teeTop: '┬',
-    teeBottom: '┴',
-    cross: '┼',
-  },
-  surface: {
-    top: '▄',
-    bottom: '▀',
-    cursor: '█',
-    altCursor: '▌',
-  },
-  navigation: {
-    selected: '▸',
-    collapsed: '▸',
-    expanded: '▾',
-    up: '↑',
-    down: '↓',
-    moreAbove: '▲',
-    moreBelow: '▼',
-    next: '→',
-    back: '←',
-    pipeSeparator: '│',
-  },
-  status: {
-    success: '✓',
-    failure: '✕',
-    pending: '•',
-    active: '●',
-    idle: '○',
-    info: '•',
-    blocked: '⊘',
-    skipped: '◇',
-    review: '◈',
-    retry: '↻',
-    handoff: '⇢',
-    reference: '↗',
-    partial: '◐',
-    dualPane: '◆',
-    star: '★',
-  },
-  meter: {
-    filled: '█',
-    medium: '▓',
-    light: '▒',
-    empty: '░',
-    spark: ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'],
-  },
-} as const;
+// ---------------------------------------------------------------------------
+// ui-primitives.ts — glyph registry + tone-token table.
+//
+// W4-R4: these four tables (GLYPHS, UI_TONES, DIFF_TONES, SPINNER_FRAMES) are
+// no longer minted locally. They are the SDK presentation contract
+// (@pellux/goodvibes-sdk/platform/presentation, landed by W4-S1), consumed here
+// so the agent and the TUI share ONE source (Mike's move-to-SDK ruling —
+// machinery needed by 2+ surfaces => SDK). See
+// docs/decisions/2026-07-05-presentation-contract-sdk-extraction.md in the SDK.
+//
+// Re-exported under the historical names (GLYPHS, UI_TONES) so every existing
+// importer keeps working with no call-site churn. UI_TONES is the dark-mode
+// tone table (== resolveTones('dark')); light is resolved via theme.ts's
+// activeUiTones() / resolveUiTones(), which composes the mode dimension over
+// the SDK's resolveTones().
+//
+// Visible glyph convergence (deliberate, per S1's divergence ruling): the
+// agent's status glyphs adopt the TUI reference — idle ○ (U+25CB) -> ◌ (U+25CC),
+// info • (U+2022) -> ○ (U+25CB), and a new warn ⚠ key. Called out here so the
+// render-time change is not mistaken for a regression.
+// ---------------------------------------------------------------------------
 
-export const UI_TONES = {
-  fg: {
-    primary: '#e2e8f0',
-    secondary: '#cbd5e1',
-    muted: '#94a3b8',
-    dim: '#475569',
-    inverse: '#0f172a',
-  },
-  bg: {
-    base: '#11131a',
-    surface: '#161a22',
-    title: '#0f172a',
-    section: '#18202b',
-    summary: '#1b2430',
-    selected: '#223049',
-    input: '#1e293b',
-    warning: '#2b2116',
-    error: '#2a161b',
-    success: '#14241b',
-  },
-  state: {
-    info: '#38bdf8',
-    good: '#22c55e',
-    warn: '#f59e0b',
-    bad: '#ef4444',
-    blocked: '#f97316',
-    active: '#60a5fa',
-  },
-  accent: {
-    browser: '#7dd3fc',
-    control: '#22d3ee',
-    inspector: '#c4b5fd',
-    workflow: '#fbbf24',
-    conversation: '#93c5fd',
-  },
-} as const;
+import {
+  GLYPHS,
+  TONE_TOKENS,
+  DIFF_TONES,
+  SPINNER_FRAMES,
+} from '@pellux/goodvibes-sdk/platform/presentation';
 
+export { GLYPHS, DIFF_TONES, SPINNER_FRAMES };
+
+/** The dark-mode tone-token table (== resolveTones('dark')). */
+export const UI_TONES = TONE_TOKENS;
+
+/** The glyph registry shape, preserved for existing type references. */
 export type UiGlyphRegistry = typeof GLYPHS;

package/src/runtime/bootstrap-core.ts

@@ -518,6 +518,21 @@ export async function initializeBootstrapCore(
     },
   }).catch((err) => { logger.debug('session broker create session failed at bootstrap', { err }); });
 
+  // W2A: mirror the create into the daemon spine (fire-and-forget; the local
+  // broker above stays the source of truth). kind:'agent' is the canonical record
+  // identity; participant.surfaceKind stays 'service' (the TRANSPORT axis).
+  services.sessionSpineClient.register({
+    sessionId: runtime.sessionId,
+    project: workingDir,
+    title: 'GoodVibes Agent session',
+  });
+  // Debounced heartbeat off turn activity — coalesced to one wire call per window,
+  // no title, reopen:false. Uses the ref so a resumed session id is followed.
+  runtimeUnsubs.push(
+    uiServices.events.turns.on('TURN_SUBMITTED', () => services.sessionSpineClient.heartbeat(runtimeSessionIdRef.value)),
+    uiServices.events.turns.on('TURN_COMPLETED', () => services.sessionSpineClient.heartbeat(runtimeSessionIdRef.value)),
+  );
+
   domainDispatch.syncSessionState({
     id: userSessionId,
     projectRoot: workingDir,

package/src/runtime/bootstrap-hook-bridge.ts

@@ -9,6 +9,7 @@ import { HelperModel } from '@pellux/goodvibes-sdk/platform/config';
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import { formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
 import type { SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
+import type { SessionSpineClient } from '@pellux/goodvibes-sdk/platform/runtime/session-spine';
 import type { SessionManager } from '@pellux/goodvibes-sdk/platform/sessions';
 import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
@@ -21,6 +22,8 @@ export interface ResumeSessionOptions {
   readonly requestRender: () => void;
   readonly onSessionIdChanged?: (sessionId: string) => void;
   readonly sharedSessionBroker: Pick<SharedSessionBroker, 'reopenSession'>;
+  readonly sessionSpineClient: Pick<SessionSpineClient, 'reopen'>;
+  readonly projectRoot: string;
   readonly writeLastSessionPointer: (sessionId: string) => void;
   readonly hookDispatcher: HookDispatcher;
   readonly sessionManager: SessionManager;
@@ -51,6 +54,9 @@ export function createResumeSessionHandler(options: ResumeSessionOptions): (sess
       if (meta?.provider) options.runtime.provider = meta.provider;
       options.writeLastSessionPointer(sessionId);
       void options.sharedSessionBroker.reopenSession(sessionId).catch((err) => { logger.debug('session broker reopen session failed', { err }); });
+      // W2A: mirror the reopen into the daemon spine — reopen:true is sent ONLY on
+      // this explicit user resume verb (fire-and-forget; never blocks the resume).
+      options.sessionSpineClient.reopen({ sessionId, project: options.projectRoot });
       options.conversation.log(`Resumed session: ${sessionId}`, { fg: '135' });
       const returnContextMode = getReturnContextMode(options.configManager);
       if (returnContextMode !== 'off' && meta.returnContext) {

package/src/runtime/bootstrap-shell.ts

@@ -131,6 +131,8 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     requestRender,
     onSessionIdChanged,
     sharedSessionBroker: services.sessionBroker,
+    sessionSpineClient: services.sessionSpineClient,
+    projectRoot: services.shellPaths.workingDirectory,
     writeLastSessionPointer,
     hookDispatcher: services.hookDispatcher,
     sessionManager: services.sessionManager,

package/src/runtime/bootstrap.ts

@@ -27,8 +27,10 @@ import {
   loadLastConversation,
   writeLastSessionPointer,
 } from '@/runtime/index.ts';
-import { scheduleBackgroundMcpDiscovery, startBackgroundProviderRegistration } from '@/runtime/index.ts';
+import { scheduleBackgroundMcpDiscovery } from '@/runtime/index.ts';
 import { restoreSavedModel } from '@/runtime/index.ts';
+import { runGatedLanScan } from './lan-scan-consent.ts';
+import { scheduleCalendarSubscriptionBootRefresh } from './calendar-boot-refresh.ts';
 import type { ExternalServicesHandle, HostServiceStatus, TurnEvent } from '@/runtime/index.ts';
 import type { UiRuntimeServices } from './ui-services.ts';
 import { createDeferredStartupCoordinator } from '@/runtime/index.ts';
@@ -37,6 +39,7 @@ import { createBootstrapShell } from './bootstrap-shell.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { startMcpConfigAutoReload } from '../mcp/runtime-reload.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+import { foldLegacySpineStore } from '@pellux/goodvibes-sdk/platform/runtime/session-spine';
 import { AgentPromptContextReceiptStore, composeRuntimePromptWithReceipt } from '../agent/prompt-context-receipts.ts';
 import { registerAgentAuditTool } from '../tools/agent-audit-tool.ts';
 import { registerAgentAutonomyTool } from '../tools/agent-autonomy-tool.ts';
@@ -200,9 +203,17 @@ export async function bootstrapRuntime(
     services.shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'prompt-context-receipts.jsonl'),
   );
   let activePromptTurnId: string | null = null;
+  // The current turn's raw text (Wave-4 W4-A1B): the injection seam
+  // (composeRuntimePromptWithReceipt, invoked from getSystemPrompt below) needs the
+  // active turn's intent to rank the already-eligible memory set by relevance. This is
+  // the real seam W4-A1 left unthreaded — TURN_SUBMITTED already carries `prompt`, it
+  // was just never captured. Mirrors activePromptTurnId's lifecycle exactly: set on
+  // TURN_SUBMITTED, cleared on every terminal event for that turn.
+  let activePromptTurnText: string | null = null;
   runtimeUnsubs.push(
     runtimeBus.on<Extract<TurnEvent, { type: 'TURN_SUBMITTED' }>>('TURN_SUBMITTED', (event) => {
       activePromptTurnId = event.payload.turnId;
+      activePromptTurnText = event.payload.prompt;
     }),
     runtimeBus.on<Extract<TurnEvent, { type: 'TURN_COMPLETED' }>>('TURN_COMPLETED', (event) => {
       promptContextReceipts.recordTurnOutcome({
@@ -211,7 +222,10 @@ export async function bootstrapRuntime(
         terminalEvent: 'TURN_COMPLETED',
         stopReason: event.payload.stopReason,
       });
-      if (activePromptTurnId === event.payload.turnId) activePromptTurnId = null;
+      if (activePromptTurnId === event.payload.turnId) {
+        activePromptTurnId = null;
+        activePromptTurnText = null;
+      }
     }),
     runtimeBus.on<Extract<TurnEvent, { type: 'TURN_ERROR' }>>('TURN_ERROR', (event) => {
       promptContextReceipts.recordTurnOutcome({
@@ -221,7 +235,10 @@ export async function bootstrapRuntime(
         stopReason: event.payload.stopReason,
         detail: event.payload.error,
       });
-      if (activePromptTurnId === event.payload.turnId) activePromptTurnId = null;
+      if (activePromptTurnId === event.payload.turnId) {
+        activePromptTurnId = null;
+        activePromptTurnText = null;
+      }
     }),
     runtimeBus.on<Extract<TurnEvent, { type: 'TURN_CANCEL' }>>('TURN_CANCEL', (event) => {
       promptContextReceipts.recordTurnOutcome({
@@ -231,7 +248,10 @@ export async function bootstrapRuntime(
         stopReason: event.payload.stopReason,
         detail: event.payload.reason,
       });
-      if (activePromptTurnId === event.payload.turnId) activePromptTurnId = null;
+      if (activePromptTurnId === event.payload.turnId) {
+        activePromptTurnId = null;
+        activePromptTurnText = null;
+      }
     }),
   );
   const {
@@ -270,6 +290,7 @@ export async function bootstrapRuntime(
         operatorPolicy: GOODVIBES_AGENT_OPERATOR_POLICY,
         shellPaths: services.shellPaths,
         memoryRegistry: services.memoryRegistry,
+        turnText: activePromptTurnText,
       });
       promptContextReceipts.record(composed.receipt);
       return composed.prompt;
@@ -482,6 +503,27 @@ export async function bootstrapRuntime(
       requestRender();
     },
   });
+  // W2A: probe the daemon spine OFF the interactive path. On a reachable daemon,
+  // fold the agent's own per-cwd legacy session store into it (once; marked
+  // migrated). Never starts the daemon; a down/absent daemon leaves the agent
+  // local-only with an honest offline status.
+  deferredStartup.schedule({
+    label: 'session-spine',
+    run: async () => {
+      const reachability = await services.sessionSpineClient.probeReachability();
+      if (reachability !== 'online') return;
+      foldLegacySpineStore(services.sessionSpineClient, {
+        storePath: services.shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'control-plane', 'sessions.json'),
+        markerPath: services.shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'control-plane', 'sessions.spine-folded.json'),
+        project: workingDir,
+        log: logger,
+      });
+    },
+    onError: (error) => {
+      logger.debug('Deferred session-spine startup failed', { error: summarizeError(error) });
+    },
+  });
+
   const toolCount = toolRegistry.list().length;
   conversation.splashOptions = {
     workingDir,
@@ -492,8 +534,14 @@ export async function bootstrapRuntime(
 
   // ── Phase 8: Background provider registration (non-blocking) ────────────
   // These run after the initial render so they don't delay startup.
+  //
+  // Gated: the SDK's discovery pass probes every host on the local subnet
+  // unconditionally, so it is only ever invoked through runGatedLanScan,
+  // which requires an explicit, persisted consent decision first and reframes
+  // whatever the SDK emits into a single honest summary line. See
+  // src/runtime/lan-scan-consent.ts.
 
-  startBackgroundProviderRegistration({
+  runGatedLanScan({
     configManager,
     providerRegistry,
     runtime,
@@ -503,6 +551,17 @@ export async function bootstrapRuntime(
     shellPaths: services.shellPaths,
     surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
   });
+  // W4-A9: refresh explicitly-subscribed external calendar feeds that are DUE
+  // per their own bounded interval (conditional 304 requests keep it cheap).
+  // Consent was given at subscribe time ("now and on each refresh"); with no
+  // subscriptions this touches nothing. Non-blocking — boot never waits on it;
+  // one honest aggregate line only when something refreshed or failed.
+  void scheduleCalendarSubscriptionBootRefresh({
+    shellPaths: services.shellPaths,
+    secretsManager: services.secretsManager,
+    systemMessageRouter,
+    requestRender,
+  });
   const mcpDiscovery = scheduleBackgroundMcpDiscovery({
     mcpRegistry: services.mcpRegistry,
     systemMessageRouter,
@@ -597,6 +656,10 @@ export async function bootstrapRuntime(
     commandRegistry,
     systemMessageRouter,
     shutdown: async (sessionData) => {
+      // W2A: best-effort spine close (short timeout, fire-and-forget) then stop
+      // the heartbeat timer. Tolerates a racing daemon stop; never blocks teardown.
+      services.sessionSpineClient.close(runtime.sessionId);
+      services.sessionSpineClient.dispose();
       // Clear bootstrap-owned subscriptions
       bootstrapUnsubs.forEach(fn => fn());
       bootstrapUnsubs.length = 0;

package/src/runtime/calendar-boot-refresh.ts

@@ -0,0 +1,105 @@
+/**
+ * Calendar subscription boot refresh (W4-A9 completion).
+ *
+ * Fires once from bootstrap's Phase-8 area (after first render, like the gated
+ * LAN scan and MCP discovery), fully async and non-blocking: boot never waits on
+ * the network. Consent was given at subscribe time — the subscribe flow states
+ * "this will fetch the calendar from the URL you provided, now and on each
+ * refresh" — so refreshing already-subscribed feeds at boot is the promised
+ * behavior, not a silent new fetch. Feeds that were never subscribed are never
+ * touched; when there are no subscriptions this function does nothing at all
+ * (no network, no store write, no activity line).
+ *
+ * Bounded: only feeds actually DUE per their per-subscription refresh interval
+ * are fetched (`force: false` — the SDK store skips the rest without network),
+ * and due fetches send stored etag/last-modified validators so an unchanged
+ * feed costs one conditional 304 round trip.
+ *
+ * Honest reporting: ONE aggregate activity line, emitted only when something
+ * was actually checked or failed — e.g.
+ *   [Calendar] checked 2 subscriptions (1 updated); 'work' unreachable — will retry next refresh
+ * A conditional-GET 304 ("not-modified") means the feed WAS checked but had
+ * nothing new — F6 fix: that no longer counts toward "updated", so the line
+ * never claims something changed when the round trip only confirmed nothing
+ * did. An all-skipped (nothing due) boot stays silent. Failures keep the
+ * last-good cached events, and /calendar subscriptions still shows the honest
+ * per-feed health (unreachable / parse-error / stale with age).
+ */
+import { logger, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { ShellPathService } from '@/runtime/index.ts';
+import {
+  CalendarSubscriptionRegistry,
+  createHttpFeedFetcher,
+  type RefreshOutcome,
+  type SubscriptionSecretStore,
+} from '../agent/calendar-subscription-registry.ts';
+
+interface SystemMessageSinkLike {
+  low(message: string): void;
+}
+
+export interface CalendarBootRefreshOptions {
+  readonly shellPaths: Pick<ShellPathService, 'resolveUserPath'>;
+  readonly secretsManager: SubscriptionSecretStore;
+  readonly systemMessageRouter: SystemMessageSinkLike;
+  readonly requestRender: () => void;
+  /** Injectable for tests — production callers omit it and get the real registry (real HTTP fetch). */
+  readonly buildRegistry?: () => CalendarSubscriptionRegistry;
+}
+
+/**
+ * Build the single aggregate line from refresh outcomes, or null when nothing
+ * user-visible happened (everything skipped as not-due).
+ *
+ * F6 fix: a 304-not-modified round trip is a genuine check (it counts toward
+ * "checked N subscriptions"), but it is NOT a change — only outcome ===
+ * 'updated' counts toward "(M updated)". The old wording ("refreshed N")
+ * counted both the same, so an all-304 boot ("nothing changed anywhere")
+ * still read as "refreshed 2 subscriptions", which claims an update that
+ * never happened.
+ */
+export function formatCalendarBootRefreshLine(outcomes: readonly RefreshOutcome[]): string | null {
+  const checked = outcomes.filter((o) => o.outcome === 'updated' || o.outcome === 'not-modified');
+  const updated = checked.filter((o) => o.outcome === 'updated');
+  const failed = outcomes.filter((o) => o.outcome === 'unreachable' || o.outcome === 'parse-error');
+  if (checked.length === 0 && failed.length === 0) return null;
+
+  const parts: string[] = [];
+  if (checked.length > 0) {
+    parts.push(`checked ${checked.length} subscription${checked.length === 1 ? '' : 's'} (${updated.length} updated)`);
+  }
+  for (const f of failed) {
+    const label = f.outcome === 'unreachable' ? 'unreachable' : 'parse error';
+    parts.push(`'${f.name}' ${label} — will retry next refresh`);
+  }
+  return `[Calendar] ${parts.join('; ')}`;
+}
+
+/**
+ * Kick off the non-blocking boot refresh. Returns a promise that settles when
+ * the background pass finishes (bootstrap ignores it; tests await it). Never
+ * throws to the caller; failures are logged at debug and reported per-feed in
+ * the aggregate line.
+ */
+export function scheduleCalendarSubscriptionBootRefresh(options: CalendarBootRefreshOptions): Promise<void> {
+  const run = async (): Promise<void> => {
+    try {
+      const registry = options.buildRegistry
+        ? options.buildRegistry()
+        : CalendarSubscriptionRegistry.create(options.shellPaths, options.secretsManager, createHttpFeedFetcher());
+      if (!registry.hasAny()) return; // nothing subscribed -> no network, no line
+
+      // force:false — only feeds due per their own bounded interval are fetched;
+      // the rest are skipped without touching the network.
+      const outcomes = await registry.refresh(undefined, { force: false });
+      const line = formatCalendarBootRefreshLine(outcomes);
+      if (line !== null) {
+        options.systemMessageRouter.low(line);
+        options.requestRender();
+      }
+    } catch (error) {
+      logger.debug('Calendar subscription boot refresh failed', { error: summarizeError(error) });
+    }
+  };
+  return run();
+}