@pellux/goodvibes-agent 1.8.0 → 1.8.2

package/src/runtime/bootstrap-core.ts

@@ -1,4 +1,5 @@
 import { ConversationManager } from '../core/conversation';
+import { registerSessionConversation } from './conversation-rewind-port.ts';
 import { SelectionManager } from '../input/selection.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { ConfigManager, getConfiguredSystemPrompt } from '../config/index.ts';
@@ -9,7 +10,7 @@ import { PermissionManager, createPermissionConfigReader } from '@pellux/goodvib
 import { Notifier, WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
 
 import { Compositor } from '../renderer/compositor.ts';
-import type { PermissionRequestHandler } from '@pellux/goodvibes-sdk/platform/permissions';
+import type { PermissionRequestHandler, PermissionPromptRequest } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { SystemMessageRouter } from '../core/system-message-router.ts';
 import type { ConversationFollowUpItem } from '@pellux/goodvibes-sdk/platform/core';
 import type { OrchestratorUserInputOptions } from '../core/orchestrator.ts';
@@ -19,6 +20,7 @@ import type { BootstrapOptions } from './context.ts';
 import { createFeatureFlagManager } from '@/runtime/index.ts';
 import { RuntimeEventBus } from '@/runtime/index.ts';
 import type { SessionEvent } from '@/runtime/index.ts';
+import { emitPermissionModeChanged } from '@pellux/goodvibes-sdk/platform/runtime/emitters';
 import { createRuntimeStore, createDomainDispatch, type RuntimeStore } from './store/index.ts';
 import { ForensicsCollector, ForensicsRegistry } from '@/runtime/index.ts';
 import {
@@ -135,6 +137,38 @@ export function companionMessageToOrchestratorInputOptions(
   };
 }
 
+/**
+ * Fleet-attention wiring: derive the shared-approval metadata for a
+ * permission ask. Background/subagent asks carry
+ * `request.attribution` (kind: 'background-agent', agentId, template — set by
+ * AgentOrchestrator's gateBackgroundToolCall once permissionManager is wired
+ * into it, see the `services.agentOrchestrator.setDependencies(...)` call
+ * below and orchestrator.test.ts's "background agent permission gating"
+ * suite). Forwarding `attribution.agentId` into the shared approval's
+ * `metadata.agentId` is what lets the SDK's fleet ProcessRegistry
+ * (runtime/fleet/registry.js, collectPendingApprovals) attribute the pending
+ * ask to that agent's ProcessNode — deriving
+ * `state: 'awaiting-approval'` / `needsAttention: { reason: 'approval' }` on
+ * the spawned agent itself, rather than leaving the ask an anonymous approval
+ * entry the fleet plane cannot attach to anything. Foreground asks (no
+ * attribution) return undefined, preserving today's un-attributed shape.
+ *
+ * PermissionAttribution is a discriminated union (SDK 1.6.1 added
+ * `mcp-server` and `sandbox-escalation` alongside the original
+ * `background-agent`); only `background-agent` carries an `agentId` the
+ * fleet ProcessRegistry can attach a pending approval to, so only that kind
+ * populates `metadata.agentId` here. The other two kinds are surfaced in the
+ * permission-prompt UI itself (see src/permissions/prompt.ts), not through
+ * fleet attribution metadata — an MCP server or a sandbox escalation is not
+ * a spawned agent's ProcessNode.
+ */
+export function approvalMetadataForRequest(
+  request: Pick<PermissionPromptRequest, 'attribution'>,
+): Record<string, unknown> | undefined {
+  const attribution = request.attribution;
+  return attribution?.kind === 'background-agent' ? { agentId: attribution.agentId } : undefined;
+}
+
 export async function initializeBootstrapCore(
   stdout: NodeJS.WriteStream,
   options: BootstrapOptions,
@@ -150,6 +184,15 @@ export async function initializeBootstrapCore(
   });
 
   const userSessionId = `user-${generateUserSessionId()}`;
+  // Declared here, before createRuntimeServices, so the checkpoint manager can be
+  // handed a live session-id resolver at construction time. Its value starts as
+  // the bootstrap user session id and is advanced to the real runtime session id
+  // below (see runtimeSessionIdRef.value = runtime.sessionId). Because the
+  // resolver is consulted at the moment each automatic snapshot fires — not at
+  // subscription time — reading .value through this closure keeps same-launch
+  // checkpoints stamped with whatever session id is current when the turn ends,
+  // which is exactly the id the restore/rewind lookup filters on.
+  const runtimeSessionIdRef = { value: userSessionId };
   const runtimeBus = new RuntimeEventBus();
   const store = createRuntimeStore();
   const domainDispatch = createDomainDispatch(store);
@@ -160,6 +203,7 @@ export async function initializeBootstrapCore(
     runtimeBus,
     runtimeStore: store,
     getConversationTitle: () => getConversationTitle(),
+    resolveSessionId: () => runtimeSessionIdRef.value || undefined,
     workingDir,
     homeDirectory,
   });
@@ -268,6 +312,13 @@ export async function initializeBootstrapCore(
     serviceRegistry: services.serviceRegistry,
     overflowHandler: services.overflowHandler,
     changeTracker: services.sessionChangeTracker,
+    // Same holder instance `services.contextAccountingHolder` exposes — the
+    // context_accounting tool registered here and the bind call bootstrap.ts
+    // makes after constructing the Orchestrator (see
+    // context-accounting-source.ts) must share ONE holder, otherwise the tool
+    // would read an unbound holder of its own while the real source sits on a
+    // different instance nothing reads.
+    contextAccountingHolder: services.contextAccountingHolder,
   });
   registerAgentArtifactsTool(toolRegistry, services.artifactStore, { projectRoot: services.shellPaths.workingDirectory });
   registerAgentDocumentsTool(toolRegistry, services.shellPaths, services.artifactStore);
@@ -309,7 +360,12 @@ export async function initializeBootstrapCore(
   });
   installToolExecutionSafetyGuard(toolRegistry);
   compactRegisteredToolDefinitions(toolRegistry);
-  services.agentOrchestrator.setDependencies({
+  // Captured so the permissionManager-bearing follow-up call below (issued once
+  // permissionManager exists, further down this function) can replay every
+  // field — AgentOrchestrator.setDependencies() fully replaces its stored
+  // toolDeps rather than merging, so a partial second call would silently drop
+  // everything set here.
+  const agentOrchestratorToolDeps = {
     surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
     fileCache,
     projectIndex,
@@ -334,7 +390,8 @@ export async function initializeBootstrapCore(
     memoryRegistry: services.memoryRegistry,
     sandboxSessionRegistry: services.sandboxSessionRegistry,
     workflowServices: services.workflow,
-  });
+  };
+  services.agentOrchestrator.setDependencies(agentOrchestratorToolDeps);
 
   const bootstrapUnsubs: Array<() => void> = [];
   // D5 fix: stop the heartbeat watcher on shutdown so the setInterval is cleared.
@@ -421,7 +478,6 @@ export async function initializeBootstrapCore(
   };
   void approvalBroker.start();
   void sharedSessionBroker.start();
-  const runtimeSessionIdRef = { value: userSessionId };
   const systemMessageRouterRef: { value: SystemMessageRouter | null } = { value: null };
   const conversationFollowUpRef: { value: ((item: ConversationFollowUpItem) => void) | null } = { value: null };
   const { unsubs: runtimeUnsubs, agentStatusIntervalRef } = registerAgentRuntimeEvents({
@@ -432,6 +488,7 @@ export async function initializeBootstrapCore(
     requestRender,
     configManager,
     agentManager: services.agentManager,
+    toolRegistry,
   });
 
   // Subscribe to companion main-chat messages received from the connected host's HTTP layer.
@@ -515,17 +572,30 @@ export async function initializeBootstrapCore(
   await syncConfiguredServices(domainDispatch.syncIntegration, services.serviceRegistry);
 
   const permissionManager = new PermissionManager(
-    (request) => approvalBroker.requestApproval({
-      request,
-      sessionId: runtimeSessionIdRef.value,
-      localPrompt: permissionPromptRef.requestPermission,
-    }),
+    (request) => {
+      const metadata = approvalMetadataForRequest(request);
+      return approvalBroker.requestApproval({
+        request,
+        sessionId: runtimeSessionIdRef.value,
+        localPrompt: permissionPromptRef.requestPermission,
+        ...(metadata ? { metadata } : {}),
+      });
+    },
     createPermissionConfigReader(configManager),
     policyRuntimeState,
     services.hookDispatcher,
     featureFlags,
   );
   installPermissionManagerSafetyGuard(permissionManager);
+  // Wire permissionManager into the SAME AgentOrchestrator instance that runs
+  // spawned/background agent tool calls (services.agentOrchestrator, set up
+  // above with agentOrchestratorToolDeps before permissionManager existed).
+  // Without this, the SDK's gateBackgroundToolCall() sees no permissionManager
+  // on context and leaves every background tool call ungated — spawned agents
+  // would run with no permission check at all, regardless of permissions.mode
+  // or permissions.backgroundAgents. Replays the full toolDeps object because
+  // setDependencies() replaces rather than merges.
+  services.agentOrchestrator.setDependencies({ ...agentOrchestratorToolDeps, permissionManager });
   await hookWorkbench.loadAndApplyManagedHooks();
 
   const runtime: MutableRuntimeState = {
@@ -537,10 +607,21 @@ export async function initializeBootstrapCore(
     sessionId: userSessionId,
   };
   runtimeSessionIdRef.value = runtime.sessionId;
+  // Register this process's live conversation so the composed daemon's
+  // rewind.plan/apply verbs can serve conversation scope for this session
+  // (see conversation-rewind-port.ts and services.ts's conversationRewindPort
+  // wiring). Ported from goodvibes-tui's identical bootstrap-time call.
+  registerSessionConversation(runtime.sessionId, conversation);
   void sharedSessionBroker.createSession({
     id: runtime.sessionId,
     title: 'GoodVibes Agent session',
-    metadata: { source: 'goodvibes-agent' },
+    // Declares the session permission mode at creation time in the shared
+    // metadata bag (SDK 1.6.1 permissions.mode: prompt/allow-all/custom/
+    // plan/accept-edits). Read-only declaration — the permission layer
+    // itself always reads permissions.mode live off configManager, so this
+    // does not change enforcement; it lets cross-session tooling see which
+    // mode a session started under without re-deriving it.
+    metadata: { source: 'goodvibes-agent', permissionMode: configManager.get('permissions.mode') },
     participant: {
       surfaceKind: 'service',
       surfaceId: 'surface:goodvibes-agent',
@@ -564,6 +645,26 @@ export async function initializeBootstrapCore(
     uiServices.events.turns.on('TURN_COMPLETED', () => services.sessionSpineClient.heartbeat(runtimeSessionIdRef.value)),
   );
 
+  // Producer half of the live mode-metadata refresh. permissions.mode can change
+  // mid-session (the Permission mode setting cycles it via configManager), and
+  // the SDK models that as a PERMISSION_MODE_CHANGED wire event — but nothing
+  // emitted it, so the runtime store's permission domain (and any surface built
+  // off it) stayed frozen at the boot-time value until restart. Bridging the
+  // config-key subscription onto the runtime bus makes every mode mutation, from
+  // any path that goes through configManager.set, publish the event; the
+  // consumer half in agent-runtime-events.ts folds it into the store and shows a
+  // system message. Guarded on an actual change so a no-op re-set stays silent.
+  runtimeUnsubs.push(
+    configManager.subscribe('permissions.mode', (newValue, oldValue) => {
+      if (newValue === oldValue) return;
+      emitPermissionModeChanged(
+        runtimeBus,
+        { sessionId: runtimeSessionIdRef.value, source: 'goodvibes-agent', traceId: `perm-mode-${generateUserSessionId()}` },
+        { mode: String(newValue), previousMode: String(oldValue) },
+      );
+    }),
+  );
+
   domainDispatch.syncSessionState({
     id: userSessionId,
     projectRoot: workingDir,

package/src/runtime/bootstrap-external-services.ts

@@ -0,0 +1,156 @@
+/**
+ * Connected-host (daemon + HTTP listener) discovery for GoodVibes Agent.
+ *
+ * Split out of bootstrap.ts (which is near the 800-line architecture cap) to
+ * keep this concern — and its "GoodVibes Agent never owns the daemon
+ * lifecycle" framing — in one small, readable place.
+ *
+ * GoodVibes Agent never starts or restarts the connected daemon: every call
+ * routes through the SDK-shared adopt-or-spawn policy
+ * (decideDaemonAdoption/classifyDaemonProbe) with `adoptOnly: true`, so a
+ * reachable, version-compatible daemon is adopted and anything else (absent,
+ * blocked, or on an incompatible wire version) is reported honestly. This
+ * replaces a local stub that hard-declared every daemon 'external' without
+ * probing or version-checking it.
+ */
+import { startExternalServices } from '@/runtime/index.ts';
+import type {
+  DeferredStartupCoordinator,
+  ExternalServicesHandle,
+  HostServiceStatus,
+  HostServicesConfig,
+  RuntimeEventBus,
+} from '@/runtime/index.ts';
+import type { HookDispatcher } from '@pellux/goodvibes-sdk/platform/hooks';
+import { logger, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { SystemMessageRouter } from '../core/system-message-router.ts';
+import type { RuntimeServices } from './services.ts';
+import type { UiRuntimeServices } from './ui-services.ts';
+
+function formatHostServiceBaseUrl(host: string, port: number): string {
+  const normalized = host.trim().toLowerCase();
+  const probeHost = normalized === '0.0.0.0'
+    ? '127.0.0.1'
+    : normalized === '::' || normalized === '[::]'
+      ? '::1'
+      : host;
+  const urlHost = probeHost.includes(':') && !probeHost.startsWith('[') ? `[${probeHost}]` : probeHost;
+  return `http://${urlHost}:${port}`;
+}
+
+// Pending status shown before the deferred probe completes — honest
+// 'unavailable', never a guessed 'external'.
+function createPendingServiceStatus(
+  configManager: HostServicesConfig,
+  service: 'daemon' | 'httpListener',
+): HostServiceStatus {
+  const host = String(configManager.get(service === 'daemon' ? 'controlPlane.host' : 'httpListener.host') ?? '127.0.0.1');
+  const port = Number(configManager.get(service === 'daemon' ? 'controlPlane.port' : 'httpListener.port') ?? (service === 'daemon' ? 3421 : 3422));
+  return {
+    mode: 'unavailable',
+    host,
+    port,
+    baseUrl: formatHostServiceBaseUrl(host, port),
+    reason: 'Connected-host discovery has not completed yet',
+  };
+}
+
+const hostServiceIsActive = (status: HostServiceStatus): boolean => status.mode === 'embedded' || status.mode === 'external';
+
+// 'blocked' (occupied by an unverified process) and 'incompatible' (a
+// GoodVibes daemon on a wire-version band this Agent build refuses to adopt)
+// both mean the configured port is held and unusable by this instance.
+const hostServiceIsBlocked = (status: HostServiceStatus): boolean => status.mode === 'blocked' || status.mode === 'incompatible';
+
+export interface AgentExternalServicesController {
+  /** The most recently resolved (or pending) connected-host status. */
+  getStatus(): ExternalServicesHandle;
+  stop(): Promise<void>;
+}
+
+export function wireAgentExternalServices(options: {
+  readonly configManager: HostServicesConfig;
+  readonly runtimeBus: RuntimeEventBus;
+  readonly hookDispatcher: HookDispatcher;
+  readonly services: RuntimeServices;
+  readonly uiServices: UiRuntimeServices;
+  readonly deferredStartup: DeferredStartupCoordinator;
+  readonly systemMessageRouter: SystemMessageRouter;
+  readonly requestRender: () => void;
+}): AgentExternalServicesController {
+  const { configManager, runtimeBus, hookDispatcher, services, uiServices, deferredStartup, systemMessageRouter, requestRender } = options;
+
+  const inspectAgentDependencies = () => {
+    const daemonStatus = externalServices.daemonStatus;
+    const httpListenerStatus = externalServices.httpListenerStatus;
+    return {
+      connectedHostRunning: hostServiceIsActive(daemonStatus),
+      connectedHostPortInUse: hostServiceIsBlocked(daemonStatus),
+      httpListenerRunning: hostServiceIsActive(httpListenerStatus),
+      httpListenerPortInUse: hostServiceIsBlocked(httpListenerStatus),
+      connectedHostStatus: daemonStatus,
+      httpListenerStatus,
+    };
+  };
+
+  let externalServices: ExternalServicesHandle = {
+    daemonServer: null,
+    httpListener: null,
+    daemonStatus: createPendingServiceStatus(configManager, 'daemon'),
+    httpListenerStatus: createPendingServiceStatus(configManager, 'httpListener'),
+    listRecentControlPlaneEvents: () => [],
+    async stop(): Promise<void> {},
+  };
+  let externalServicesPromise: Promise<ExternalServicesHandle> | null = null;
+
+  const startAgentExternalServices = (): Promise<ExternalServicesHandle> =>
+    startExternalServices(configManager, runtimeBus, hookDispatcher, services, { adoptOnly: true });
+
+  const platformExternalServices = uiServices.platform as typeof uiServices.platform & {
+    externalServices: NonNullable<typeof uiServices.platform.externalServices>;
+  };
+  platformExternalServices.externalServices = {
+    inspect: inspectAgentDependencies,
+    restart: async () => {
+      if (externalServicesPromise) {
+        try {
+          externalServices = await externalServicesPromise;
+        } catch {
+          // A failed previous startup should not prevent a re-probe attempt.
+        }
+      }
+      await externalServices.stop();
+      externalServicesPromise = startAgentExternalServices();
+      externalServices = await externalServicesPromise;
+      systemMessageRouter.high('[Startup] GoodVibes Agent does not start or restart the connected GoodVibes host — it adopted the current status from a fresh probe.');
+      requestRender();
+      return inspectAgentDependencies();
+    },
+  };
+
+  // Connected-host discovery OFF the interactive path: probe the configured
+  // host/port through the shared adopt-or-spawn policy (adoptOnly — Agent
+  // never spawns or embeds) and replace the pending status with an honest
+  // one (adopted, incompatible, blocked, or unavailable).
+  deferredStartup.schedule({
+    label: 'external-services',
+    run: async () => {
+      externalServicesPromise = startAgentExternalServices();
+      externalServices = await externalServicesPromise;
+      requestRender();
+    },
+    onError: (error) => {
+      const message = summarizeError(error);
+      logger.error('Deferred connected-host discovery failed', { error: message });
+      systemMessageRouter.high(`[Startup] Connected-host discovery failed: ${message}`);
+      requestRender();
+    },
+  });
+
+  return {
+    getStatus: () => externalServices,
+    stop: async () => {
+      await externalServices.stop();
+    },
+  };
+}

package/src/runtime/bootstrap.ts

@@ -31,10 +31,12 @@ 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 { TurnEvent } from '@/runtime/index.ts';
 import type { UiRuntimeServices } from './ui-services.ts';
 import { createDeferredStartupCoordinator } from '@/runtime/index.ts';
+import { wireAgentExternalServices } from './bootstrap-external-services.ts';
 import { initializeBootstrapCore } from './bootstrap-core.ts';
+import { bindOrchestratorContextAccounting } from './context-accounting-source.ts';
 import { createBootstrapShell } from './bootstrap-shell.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { startMcpConfigAutoReload } from '../mcp/runtime-reload.ts';
@@ -42,6 +44,9 @@ import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { foldLegacySpineStore } from '@pellux/goodvibes-sdk/platform/runtime/session-spine';
 import { reconcileMemorySpineAdoption } from './memory-spine-adoption.ts';
 import { AgentPromptContextReceiptStore, composeRuntimePromptWithReceipt } from '../agent/prompt-context-receipts.ts';
+import { createMemoryConsolidationScheduler } from './memory-consolidation-wiring.ts';
+import { recordTurnAnchor, summarizeTurnLabel } from '../core/rewind-turn-anchors.ts';
+import { createMemoryUsageTracker } from './memory-usage-wiring.ts';
 import { registerAgentAuditTool } from '../tools/agent-audit-tool.ts';
 import { registerAgentAutonomyTool } from '../tools/agent-autonomy-tool.ts';
 import { registerAgentChannelsTool } from '../tools/agent-channels-tool.ts';
@@ -211,6 +216,20 @@ export async function bootstrapRuntime(
   // 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;
+  // Idle-time memory consolidation: reviews stored memory when the agent is
+  // genuinely idle (no active turn) and no sooner than the configured interval,
+  // off by default. Every run leaves a receipt of what it merged/archived/proposed.
+  // Usage-outcome instrumentation: records which memories were injected and, at
+  // turn completion, whether the model output plausibly referenced them (honest
+  // heuristic overlap). Feeds consolidation's never-referenced-first decay.
+  const memoryUsageTracker = createMemoryUsageTracker(services.shellPaths, services.memoryRegistry);
+  const memoryConsolidationScheduler = createMemoryConsolidationScheduler({
+    configManager,
+    memoryRegistry: services.memoryRegistry,
+    shellPaths: services.shellPaths,
+    isIdle: () => activePromptTurnId === null,
+    usageLookup: (id) => memoryUsageTracker.lookup(id),
+  });
   runtimeUnsubs.push(
     runtimeBus.on<Extract<TurnEvent, { type: 'TURN_SUBMITTED' }>>('TURN_SUBMITTED', (event) => {
       activePromptTurnId = event.payload.turnId;
@@ -233,10 +252,30 @@ export async function bootstrapRuntime(
         terminalEvent: 'TURN_COMPLETED',
         stopReason: event.payload.stopReason,
       });
+      // Record this turn's rewind anchor: pair the turnId (shared with the
+      // workspace checkpoint the turn engine snapshots for this same turn)
+      // with the live conversation message count, so a later message-anchored
+      // rewind.plan/apply (scope 'conversation' or 'both') can truncate the
+      // conversation to exactly this boundary — the join key between
+      // conversation and files rewind (see core/rewind-turn-anchors.ts and
+      // services.ts's conversationRewindPort wiring).
+      try {
+        recordTurnAnchor(runtimeSessionIdRef.value, {
+          turnId: event.payload.turnId,
+          label: summarizeTurnLabel(conversation.getLastUserMessage()),
+          messageCount: conversation.getMessageCount(),
+          at: Date.now(),
+        });
+      } catch (error) {
+        // Best-effort; a rewind-anchor miss must never break the turn.
+        logger.debug('rewind turn-anchor recording failed', { error: summarizeError(error) });
+      }
       if (activePromptTurnId === event.payload.turnId) {
         activePromptTurnId = null;
         activePromptTurnText = null;
       }
+      memoryUsageTracker.onTurnCompleted(event.payload.turnId, event.payload.response);
+      memoryConsolidationScheduler.onTurnSettled();
     }),
     runtimeBus.on<Extract<TurnEvent, { type: 'TURN_ERROR' }>>('TURN_ERROR', (event) => {
       promptContextReceipts.recordTurnOutcome({
@@ -250,6 +289,8 @@ export async function bootstrapRuntime(
         activePromptTurnId = null;
         activePromptTurnText = null;
       }
+      memoryUsageTracker.onTurnAborted(event.payload.turnId);
+      memoryConsolidationScheduler.onTurnSettled();
     }),
     runtimeBus.on<Extract<TurnEvent, { type: 'TURN_CANCEL' }>>('TURN_CANCEL', (event) => {
       promptContextReceipts.recordTurnOutcome({
@@ -263,6 +304,8 @@ export async function bootstrapRuntime(
         activePromptTurnId = null;
         activePromptTurnText = null;
       }
+      memoryUsageTracker.onTurnAborted(event.payload.turnId);
+      memoryConsolidationScheduler.onTurnSettled();
     }),
   );
   const {
@@ -305,6 +348,7 @@ export async function bootstrapRuntime(
         memoryRecallSnapshot: services.memorySpineClient.recallSnapshot(),
       });
       promptContextReceipts.record(composed.receipt);
+      memoryUsageTracker.onComposed(activePromptTurnId, composed.receipt);
       return composed.prompt;
     },
     hookDispatcher,
@@ -336,6 +380,20 @@ export async function bootstrapRuntime(
   });
   conversation.setSessionLineageTracker(services.sessionLineageTracker);
 
+  // Bind the context_accounting tool (SDK 1.6.1) to THIS Orchestrator so it
+  // reports real session data instead of the unbound-holder honesty message.
+  // Must run after setCoreServices (nothing here depends on it, but this
+  // keeps every orchestrator.* wiring call grouped) and before the first
+  // turn — see context-accounting-source.ts for what each facet reads.
+  runtimeUnsubs.push(bindOrchestratorContextAccounting({
+    orchestrator,
+    holder: services.contextAccountingHolder,
+    runtimeBus,
+    runtimeStore: store,
+    sessionId: runtime.sessionId,
+    getContextWindow: () => providerRegistry.getContextWindowForModel(providerRegistry.getCurrentModel()),
+  }));
+
   const opsTaskManager = createTaskManager(store, runtimeBus, userSessionId);
   const opsControlPlane = services.featureFlags.isEnabled('operator-control-plane')
     ? new OpsControlPlane(opsTaskManager, runtimeBus, store, userSessionId)
@@ -420,74 +478,20 @@ export async function bootstrapRuntime(
 
   const deferredStartup = createDeferredStartupCoordinator();
 
-  const formatHostServiceBaseUrl = (host: string, port: number): string => {
-    const normalized = host.trim().toLowerCase();
-    const probeHost = normalized === '0.0.0.0'
-      ? '127.0.0.1'
-      : normalized === '::' || normalized === '[::]'
-        ? '::1'
-        : host;
-    const urlHost = probeHost.includes(':') && !probeHost.startsWith('[') ? `[${probeHost}]` : probeHost;
-    return `http://${urlHost}:${port}`;
-  };
-
-  const createAgentDependencyStatus = (
-    service: 'daemon' | 'httpListener',
-  ): HostServiceStatus => {
-    const host = String(configManager.get(service === 'daemon' ? 'controlPlane.host' : 'httpListener.host') ?? '127.0.0.1');
-    const port = Number(configManager.get(service === 'daemon' ? 'controlPlane.port' : 'httpListener.port') ?? (service === 'daemon' ? 3421 : 3422));
-    return {
-      mode: service === 'daemon' ? 'external' : 'disabled',
-      host,
-      port,
-      baseUrl: formatHostServiceBaseUrl(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.',
-    };
-  };
-
-  const hostServiceIsActive = (status: HostServiceStatus): boolean => status.mode === 'embedded' || status.mode === 'external';
-
-  const hostServiceIsBlocked = (status: HostServiceStatus): boolean => status.mode === 'blocked';
-
-  const inspectAgentDependencies = () => {
-    const daemonStatus = externalServices.daemonStatus;
-    const httpListenerStatus = externalServices.httpListenerStatus;
-    return {
-      connectedHostRunning: hostServiceIsActive(daemonStatus),
-      connectedHostPortInUse: hostServiceIsBlocked(daemonStatus),
-      httpListenerRunning: hostServiceIsActive(httpListenerStatus),
-      httpListenerPortInUse: hostServiceIsBlocked(httpListenerStatus),
-      connectedHostStatus: daemonStatus,
-      httpListenerStatus,
-    };
-  };
+  // GoodVibes Agent never owns the connected daemon's (or HTTP listener's)
+  // lifecycle — see bootstrap-external-services.ts for the adopt-only wiring
+  // and the deferred discovery probe it schedules.
+  const agentExternalServices = wireAgentExternalServices({
+    configManager,
+    runtimeBus,
+    hookDispatcher,
+    services,
+    uiServices,
+    deferredStartup,
+    systemMessageRouter,
+    requestRender,
+  });
 
-  let externalServices: ExternalServicesHandle = {
-    daemonServer: null,
-    httpListener: null,
-    daemonStatus: createAgentDependencyStatus('daemon'),
-    httpListenerStatus: createAgentDependencyStatus('httpListener'),
-    listRecentControlPlaneEvents: () => [],
-    async stop(): Promise<void> {},
-  };
-  const platformExternalServices = uiServices.platform as typeof uiServices.platform & {
-    externalServices: NonNullable<typeof uiServices.platform.externalServices>;
-  };
-  platformExternalServices.externalServices = {
-    inspect: inspectAgentDependencies,
-    restart: async () => {
-      externalServices = {
-        ...externalServices,
-        daemonStatus: createAgentDependencyStatus('daemon'),
-        httpListenerStatus: createAgentDependencyStatus('httpListener'),
-      };
-      systemMessageRouter.high('[Startup] GoodVibes Agent does not start or restart the connected GoodVibes host. Start it from GoodVibes TUI or the owning host, then refresh status.');
-      requestRender();
-      return inspectAgentDependencies();
-    },
-  };
   deferredStartup.schedule({
     label: 'plugins',
     run: async () => {
@@ -736,7 +740,7 @@ export async function bootstrapRuntime(
       forensicsCollector.dispose();
       services.executionLedger.dispose();
       await deferredStartup.drain(100);
-      await externalServices.stop();
+      await agentExternalServices.stop();
       // Clear agent status interval via ref (consistent with agentStatusIntervalRef usage)
       if (agentStatusIntervalRef.value !== null) {
         clearInterval(agentStatusIntervalRef.value);