@pellux/goodvibes-agent 1.8.1 → 1.9.0

package/src/runtime/context-accounting-source.ts

@@ -0,0 +1,114 @@
+/**
+ * context-accounting-source.ts
+ *
+ * Binds the SDK's `context_accounting` tool (SDK 1.6.1,
+ * platform/tools/context-accounting) to THIS fork's own interactive
+ * Orchestrator so the tool reports real, live session data instead of the
+ * unbound-holder honesty message ("no live session context bound"). GoodVibes
+ * Agent is an interactive consumer with exactly one Orchestrator driving the
+ * main conversation — see bootstrap.ts, where `bindOrchestratorContextAccounting`
+ * is called once, right after the Orchestrator is constructed and
+ * `setCoreServices` has run.
+ *
+ * The three ContextAccountingSource facets map onto data this fork already
+ * tracks, nothing new is measured:
+ *   - Token state: Orchestrator.usage (input/output/cacheRead/cacheWrite,
+ *     public fields) + Orchestrator.lastInputTokens, plus the active model's
+ *     context window from providerRegistry.getContextWindowForModel — the
+ *     exact call bootstrap.ts already makes for the system prompt.
+ *   - Turn injections: Orchestrator.getTurnInjections() (public accessor).
+ *   - Compaction state: Orchestrator does not expose `isCompacting` publicly
+ *     (private field), so this reads runtimeStore.getState().session.compactionState
+ *     instead — the SAME state the SDK's own updateSessionState reducer
+ *     already derives from the 'compaction' domain's runtime-bus events (see
+ *     agent-runtime-events.ts's `runtimeBus.onDomain('compaction', ...)`
+ *     subscription, wired before this bind call runs). compactionCount is a
+ *     local counter incremented on each applied COMPACTION_RECEIPT for THIS
+ *     session — the SDK does not track a running count itself.
+ */
+import type { ContextAccountingHolder, ContextAccountingSource } from '@pellux/goodvibes-sdk/platform/tools';
+import type { Orchestrator } from '../core/orchestrator.ts';
+import type { CompactionEvent, RuntimeEventBus } from '@/runtime/index.ts';
+import type { RuntimeStore } from './store/index.ts';
+
+/** compactionState values that mean "a compaction pass is currently running" — every non-idle, non-terminal state. */
+const COMPACTING_STATES: ReadonlySet<string> = new Set([
+  'checking_threshold',
+  'microcompact',
+  'collapse',
+  'autocompact',
+  'reactive_compact',
+  'boundary_commit',
+]);
+
+export interface BindOrchestratorContextAccountingOptions {
+  /** The interactive session's Orchestrator. Only the public surface this source reads is required. */
+  readonly orchestrator: Pick<Orchestrator, 'usage' | 'lastInputTokens' | 'getTurnInjections'>;
+  readonly holder: ContextAccountingHolder;
+  readonly runtimeBus: RuntimeEventBus;
+  readonly runtimeStore: RuntimeStore;
+  /** Same sessionId passed to the Orchestrator's own constructor. */
+  readonly sessionId: string;
+  /** Resolves the active model's context window; omitted/null when unknown (matches providerRegistry.getContextWindowForModel). */
+  readonly getContextWindow: () => number | null;
+  /** Human-readable scope label so the tool's caller knows whose context this is. Defaults to 'main session'. */
+  readonly scope?: string;
+}
+
+/**
+ * Binds an Orchestrator-backed ContextAccountingSource onto `holder` and
+ * returns an unbind function (removes the compaction-receipt subscription and
+ * clears the holder back to unbound). Safe to call once per Orchestrator
+ * lifetime; bootstrap.ts pushes the returned function into `runtimeUnsubs` so
+ * shutdown leaves no dangling bus subscription.
+ */
+export function bindOrchestratorContextAccounting(
+  options: BindOrchestratorContextAccountingOptions,
+): () => void {
+  const { orchestrator, holder, runtimeBus, runtimeStore, sessionId, getContextWindow } = options;
+  const scope = options.scope ?? 'main session';
+
+  // Local running count of applied compactions for THIS session — the SDK
+  // emits the mandatory COMPACTION_RECEIPT after every compaction path
+  // (agent-runtime-events.ts routes the same event into the visible system
+  // message; this tracks only the count, filtered to this session so a
+  // background agent's own compaction does not inflate the main session's
+  // number).
+  let compactionCount = 0;
+  const unsubReceipt = runtimeBus.on<Extract<CompactionEvent, { type: 'COMPACTION_RECEIPT' }>>(
+    'COMPACTION_RECEIPT',
+    ({ payload }) => {
+      if (payload.sessionId === sessionId && payload.outcome === 'applied') compactionCount += 1;
+    },
+  );
+
+  const source: ContextAccountingSource = {
+    scope,
+    sessionId,
+    getTurnInjections: () => orchestrator.getTurnInjections(),
+    getTokenState: () => ({
+      measured: {
+        input: orchestrator.usage.input,
+        output: orchestrator.usage.output,
+        cacheRead: orchestrator.usage.cacheRead,
+        cacheWrite: orchestrator.usage.cacheWrite,
+      },
+      lastInputTokens: orchestrator.lastInputTokens,
+      contextWindow: getContextWindow(),
+    }),
+    getCompactionState: () => {
+      const compactionState = runtimeStore.getState().session.compactionState;
+      return {
+        isCompacting: COMPACTING_STATES.has(compactionState),
+        compactionCount,
+      };
+    },
+  };
+
+  holder.setSource(source);
+
+  return () => {
+    unsubReceipt();
+    holder.setSource(null);
+  };
+}

package/src/runtime/conversation-rewind-port.ts

@@ -0,0 +1,133 @@
+// ---------------------------------------------------------------------------
+// conversation-rewind-port.ts — this Agent's ConversationManager as the SDK
+// unified rewind service's RewindConversationPort.
+//
+// The SDK's UnifiedRewindService (platform/rewind) joins files rewind (workspace
+// checkpoints) with conversation rewind through two ports. The conversation port
+// is "a daemon-hosted mutable conversation store": preview() reports how many
+// messages would truncate to a recorded turn boundary, and rewind() performs the
+// truncation and captures the pre-/post-truncation snapshots so the reversal can
+// be undone and re-applied. The truncation boundary is the message count recorded
+// for the anchor's turnId at TURN_COMPLETED (rewind-turn-anchors.ts) — the same
+// join key files rewind uses against the workspace checkpoint.
+//
+// Ported from goodvibes-tui's src/runtime/conversation-rewind-port.ts (same
+// port shape, same registry pattern) so the two front-ends' rewind semantics
+// cannot drift. This Agent has no in-process /rewind command today (see
+// src/test/daemon/gateway-rewind-conversation-scope.test.ts for the honesty
+// note on that), so the only consumer of this port here is the composed
+// daemon's rewind.plan/apply verbs, resolving the live conversation per
+// anchor.sessionId from the registry below.
+// ---------------------------------------------------------------------------
+
+import type {
+  RewindAnchor,
+  RewindConversationOutcome,
+  RewindConversationPort,
+  RewindConversationPreview,
+} from '@pellux/goodvibes-sdk/platform/rewind';
+import type { ConversationManager } from '../core/conversation.ts';
+import { resolveTurnAnchor } from '../core/rewind-turn-anchors.ts';
+
+type ConversationJson = Parameters<ConversationManager['fromJSON']>[0];
+
+/** The port plus the reversal accessors an in-process undo/redo surface would need. */
+export interface ConversationRewindPort extends RewindConversationPort {
+  /** Restore the pre-truncation conversation (the undo direction). */
+  restoreBefore(undoSnapshotId: string): boolean;
+  /** Restore the post-truncation conversation (the redo direction). */
+  restoreAfter(undoSnapshotId: string): boolean;
+}
+
+/** One truncation's captured state — the target conversation and its snapshots. */
+interface SnapshotPair {
+  readonly conv: ConversationManager;
+  readonly before: ConversationJson;
+  readonly after: ConversationJson;
+}
+
+/**
+ * Build a conversation rewind port. `resolveConversation` maps an anchor's
+ * sessionId to the live ConversationManager — for this Agent (a single-session
+ * process) that is the one bound conversation when the sessionId matches, and
+ * null otherwise. A null resolution means no live conversation for that
+ * session, reported as "nothing to drop" rather than a fabricated count.
+ */
+export function createConversationRewindPort(
+  resolveConversation: (sessionId: string) => ConversationManager | null,
+): ConversationRewindPort {
+  const snapshots = new Map<string, SnapshotPair>();
+
+  function keepFor(anchor: RewindAnchor): { conv: ConversationManager | null; keep: number; total: number } {
+    const conv = resolveConversation(anchor.sessionId);
+    if (!conv) return { conv: null, keep: 0, total: 0 };
+    const total = conv.getMessageCount();
+    const rec = anchor.turnId ? resolveTurnAnchor(anchor.sessionId, anchor.turnId) : null;
+    const keep = rec ? Math.min(rec.messageCount, total) : total;
+    return { conv, keep, total };
+  }
+
+  function restore(snapshot: SnapshotPair | undefined, which: 'before' | 'after'): boolean {
+    if (!snapshot) return false;
+    snapshot.conv.fromJSON(snapshot[which]);
+    snapshot.conv.rebuildHistory();
+    return true;
+  }
+
+  return {
+    async preview(anchor: RewindAnchor): Promise<RewindConversationPreview> {
+      const { keep, total } = keepFor(anchor);
+      return { messagesToDrop: Math.max(0, total - keep), messagesRemaining: keep };
+    },
+
+    async rewind(anchor: RewindAnchor): Promise<RewindConversationOutcome> {
+      const { conv, keep, total } = keepFor(anchor);
+      const undoSnapshotId = `rwc_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+      if (!conv) return { droppedMessages: 0, undoSnapshotId };
+      const before = conv.toJSON() as ConversationJson;
+      conv.removeMessagesAfter(keep);
+      conv.rebuildHistory();
+      const after = conv.toJSON() as ConversationJson;
+      snapshots.set(undoSnapshotId, { conv, before, after });
+      return { droppedMessages: Math.max(0, total - keep), undoSnapshotId };
+    },
+
+    restoreBefore(undoSnapshotId: string): boolean {
+      return restore(snapshots.get(undoSnapshotId), 'before');
+    },
+
+    restoreAfter(undoSnapshotId: string): boolean {
+      return restore(snapshots.get(undoSnapshotId), 'after');
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Live per-session conversation registry — the daemon-hosted mutable store the
+// composed daemon's rewind.plan/apply verbs resolve conversations from. This
+// Agent registers its active session's ConversationManager at bootstrap; a
+// session with no registration reports conversation rewind as "nothing to
+// drop".
+// ---------------------------------------------------------------------------
+
+const liveConversations = new Map<string, ConversationManager>();
+
+/** Register a session's live conversation so the daemon rewind verbs can serve it. */
+export function registerSessionConversation(sessionId: string, conversation: ConversationManager): void {
+  if (sessionId) liveConversations.set(sessionId, conversation);
+}
+
+/** Drop a session's conversation registration. */
+export function unregisterSessionConversation(sessionId: string): void {
+  liveConversations.delete(sessionId);
+}
+
+/**
+ * The conversation rewind port the composed daemon threads into
+ * registerGatewayVerbGroups — it resolves each anchor's live conversation from
+ * the registry above, so the daemon's own rewind verbs serve conversation scope
+ * live in this process.
+ */
+export function createSessionConversationRewindPort(): ConversationRewindPort {
+  return createConversationRewindPort((sessionId) => liveConversations.get(sessionId) ?? null);
+}

package/src/runtime/index.ts

@@ -98,34 +98,14 @@ export const restoreSavedModel = bootstrap.restoreRuntimeModel;
 export const synchronizeConfiguredServices = bootstrap.synchronizeConfiguredServices;
 export const syncConfiguredServices = bootstrap.synchronizeConfiguredServices;
 export const registerHostRuntimeEvents = bootstrap.registerHostRuntimeEvents;
-function agentExternalHostStatus(
-  config: Bootstrap.HostServicesConfig,
-  service: 'daemon' | 'httpListener',
-): Bootstrap.HostServiceStatus {
-  const hostKey = service === 'daemon' ? 'controlPlane.host' : 'httpListener.host';
-  const portKey = service === 'daemon' ? 'controlPlane.port' : 'httpListener.port';
-  const host = String(config.get(hostKey) ?? '127.0.0.1');
-  const port = Number(config.get(portKey) ?? (service === 'daemon' ? 3421 : 3422));
-  return {
-    mode: service === 'daemon' ? 'external' : 'disabled',
-    host,
-    port,
-    baseUrl: `http://${host}:${port}`,
-    reason: service === 'daemon'
-      ? 'GoodVibes Agent connects to a GoodVibes host owned outside this product and does not start or restart it.'
-      : 'GoodVibes Agent does not own listener lifecycle.',
-  };
-}
-
-export const startHostServices: typeof bootstrap.startHostServices = async (config) => ({
-  daemonServer: null,
-  httpListener: null,
-  daemonStatus: agentExternalHostStatus(config, 'daemon'),
-  httpListenerStatus: agentExternalHostStatus(config, 'httpListener'),
-  listRecentControlPlaneEvents: () => [],
-  async stop(): Promise<void> {},
-});
-export const startExternalServices = startHostServices;
+// Shared adopt-or-spawn policy (daemon-adoption-policy.ts): probes the
+// configured host/port, band-checks any GoodVibes daemon found there, and
+// only ever ADOPTS a compatible one — Agent passes `adoptOnly: true` at the
+// call site (bootstrap.ts) so it never spawns or embeds a daemon itself. This
+// replaces a local stub that hard-declared every daemon 'external' without
+// probing or version-checking it (an unsafe divergence, resolved SDK-side).
+export const startHostServices = bootstrap.startHostServices;
+export const startExternalServices = bootstrap.startHostServices;
 export const registerBootstrapHookBridge = bootstrap.registerBootstrapHookBridge;
 export const createDeferredStartupCoordinator = bootstrap.createDeferredStartupCoordinator;
 export const shutdownRuntime = bootstrap.shutdownRuntime;

package/src/runtime/memory-consolidation-scheduler.ts

@@ -0,0 +1,67 @@
+import type { MemoryConsolidationRunReceipt, MemoryConsolidationTrigger } from '@pellux/goodvibes-sdk/platform/state';
+
+/**
+ * Decides WHEN idle-time consolidation runs, keeping the real-state idleness
+ * check and the schedule cadence out of bootstrap wiring.
+ *
+ * Idleness is defined from real runtime state: `isIdle()` returns true only when
+ * there is no active turn in flight (bootstrap wires it to
+ * `activePromptTurnId === null`). The scheduler is poked on every turn-settled
+ * event; a run fires only when the job is enabled, the agent is idle, no run is
+ * already in flight, and at least `minIntervalMs` has elapsed since the last run.
+ * The same `maybeRun` path also serves an explicit trigger.
+ */
+export interface MemoryConsolidationSchedulerDeps {
+  /** Master switch — reads the resolved config's `enabled` (default false). */
+  readonly isEnabled: () => boolean;
+  /** Real-state idleness: true only when no turn is in flight. */
+  readonly isIdle: () => boolean;
+  /** Minimum ms between runs (the schedule cadence). */
+  readonly minIntervalMs: () => number;
+  /** Monotonic-enough clock, injected for tests. */
+  readonly now: () => number;
+  /** Performs the work + persists the receipt; returns it, or null when it did nothing. */
+  readonly run: (trigger: MemoryConsolidationTrigger) => MemoryConsolidationRunReceipt | null;
+}
+
+export type MemoryConsolidationSkipReason =
+  | 'disabled'
+  | 'busy'
+  | 'not-idle'
+  | 'interval-not-elapsed';
+
+export interface MemoryConsolidationSchedulerOutcome {
+  readonly ran: boolean;
+  readonly skipped?: MemoryConsolidationSkipReason;
+  readonly receipt?: MemoryConsolidationRunReceipt;
+}
+
+export class MemoryConsolidationScheduler {
+  private lastRunAt = 0;
+  private running = false;
+
+  public constructor(private readonly deps: MemoryConsolidationSchedulerDeps) {}
+
+  /** Poke from a turn-settled event — the natural moment the agent becomes idle. */
+  public onTurnSettled(): MemoryConsolidationSchedulerOutcome {
+    return this.maybeRun('idle');
+  }
+
+  public maybeRun(trigger: MemoryConsolidationTrigger): MemoryConsolidationSchedulerOutcome {
+    if (!this.deps.isEnabled()) return { ran: false, skipped: 'disabled' };
+    if (this.running) return { ran: false, skipped: 'busy' };
+    if (!this.deps.isIdle()) return { ran: false, skipped: 'not-idle' };
+    const now = this.deps.now();
+    if (this.lastRunAt !== 0 && now - this.lastRunAt < this.deps.minIntervalMs()) {
+      return { ran: false, skipped: 'interval-not-elapsed' };
+    }
+    this.running = true;
+    try {
+      const receipt = this.deps.run(trigger);
+      this.lastRunAt = now;
+      return receipt ? { ran: true, receipt } : { ran: true };
+    } finally {
+      this.running = false;
+    }
+  }
+}

package/src/runtime/memory-consolidation-wiring.ts

@@ -0,0 +1,56 @@
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import {
+  resolveMemoryConsolidationConfig,
+  runMemoryConsolidation,
+  type MemoryRegistry,
+  type MemoryConsolidationUsageLookup,
+} from '@pellux/goodvibes-sdk/platform/state';
+import { logger, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { MemoryConsolidationReceiptStore } from '../agent/memory-consolidation-receipts.ts';
+import { MemoryConsolidationScheduler } from './memory-consolidation-scheduler.ts';
+
+/**
+ * Assemble the idle-time memory consolidation scheduler from its runtime deps.
+ * Kept out of bootstrap so the run callback (config read → run → persist receipt)
+ * lives next to the rest of the consolidation module rather than inline in the
+ * boot sequence.
+ */
+export interface MemoryConsolidationWiringInput {
+  readonly configManager: Pick<ConfigManager, 'getRaw'>;
+  readonly memoryRegistry: MemoryRegistry;
+  readonly shellPaths: ShellPathService;
+  /** Real-state idleness: no turn in flight. */
+  readonly isIdle: () => boolean;
+  /** Optional usage instrumentation so never-referenced records decay first. */
+  readonly usageLookup?: MemoryConsolidationUsageLookup;
+}
+
+export function createMemoryConsolidationScheduler(input: MemoryConsolidationWiringInput): MemoryConsolidationScheduler {
+  const receipts = new MemoryConsolidationReceiptStore(input.shellPaths);
+  return new MemoryConsolidationScheduler({
+    isEnabled: () => resolveMemoryConsolidationConfig(input.configManager).enabled,
+    isIdle: input.isIdle,
+    minIntervalMs: () => resolveMemoryConsolidationConfig(input.configManager).intervalMs,
+    now: () => Date.now(),
+    run: (trigger) => {
+      try {
+        const config = resolveMemoryConsolidationConfig(input.configManager);
+        if (!config.enabled) return null;
+        const receipt = runMemoryConsolidation({
+          memoryRegistry: input.memoryRegistry,
+          config,
+          now: Date.now(),
+          trigger,
+          idle: input.isIdle(),
+          ...(input.usageLookup ? { usageLookup: input.usageLookup } : {}),
+        });
+        receipts.record(receipt);
+        return receipt;
+      } catch (error) {
+        logger.debug('Idle memory consolidation run failed', { error: summarizeError(error) });
+        return null;
+      }
+    },
+  });
+}

package/src/runtime/memory-usage-wiring.ts

@@ -0,0 +1,75 @@
+import {
+  MemoryUsageStatsStore,
+  detectReferencedMemoryIds,
+  type MemoryRegistry,
+  type MemoryConsolidationUsageSignal,
+  type MemoryReferenceInput,
+} from '@pellux/goodvibes-sdk/platform/state';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+import type { PromptContextReceiptDraft } from '../agent/prompt-context-receipts.ts';
+
+/**
+ * Ties the two ends of a turn together for usage-outcome instrumentation:
+ * records which memory ids were injected when a prompt is composed, then when the
+ * turn completes runs heuristic reference detection over the model's output to
+ * mark which of those injections were plausibly used. Aborted turns (error or
+ * cancel) simply forget the injection — no reference credit is invented.
+ */
+export function extractInjectedMemoryIds(receipt: PromptContextReceiptDraft): string[] {
+  const segment = receipt.segments.find((entry) => entry.id === 'memory');
+  const selected = segment?.selected ?? [];
+  const ids: string[] = [];
+  for (const entry of selected) {
+    const id = (entry as Record<string, unknown>).id;
+    if (typeof id === 'string' && id.trim()) ids.push(id);
+  }
+  return ids;
+}
+
+export class MemoryUsageTracker {
+  private readonly injectedByTurn = new Map<string, readonly string[]>();
+
+  public constructor(
+    private readonly store: MemoryUsageStatsStore,
+    private readonly memoryRegistry: MemoryRegistry,
+  ) {}
+
+  /** At prompt composition: count the injection and remember it for this turn. */
+  public onComposed(turnId: string | null, receipt: PromptContextReceiptDraft): void {
+    const ids = extractInjectedMemoryIds(receipt);
+    if (ids.length === 0) return;
+    this.store.recordInjected(ids);
+    if (turnId) this.injectedByTurn.set(turnId, ids);
+  }
+
+  /** At turn completion: detect which injected memories the output plausibly used. */
+  public onTurnCompleted(turnId: string, response: string): void {
+    const ids = this.injectedByTurn.get(turnId);
+    this.injectedByTurn.delete(turnId);
+    if (!ids || ids.length === 0) return;
+    const records: MemoryReferenceInput[] = [];
+    for (const id of ids) {
+      const record = this.memoryRegistry.get(id);
+      if (record) records.push({ id: record.id, summary: record.summary, detail: record.detail });
+    }
+    if (records.length === 0) return;
+    const result = detectReferencedMemoryIds(response, records);
+    if (result.referenced.length > 0) this.store.recordReferenced(result.referenced);
+  }
+
+  /** At turn error/cancel: forget the injection without crediting a reference. */
+  public onTurnAborted(turnId: string): void {
+    this.injectedByTurn.delete(turnId);
+  }
+
+  /** Consolidation decay-ordering seam. */
+  public lookup(id: string): MemoryConsolidationUsageSignal | undefined {
+    return this.store.lookup(id);
+  }
+}
+
+export function createMemoryUsageTracker(shellPaths: ShellPathService, memoryRegistry: MemoryRegistry): MemoryUsageTracker {
+  const store = new MemoryUsageStatsStore(shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'learning', 'memory-usage.json'));
+  return new MemoryUsageTracker(store, memoryRegistry);
+}