@pellux/goodvibes-agent 1.9.1 → 1.10.0

package/src/runtime/release-artifacts.ts

@@ -0,0 +1,113 @@
+/**
+ * Names and shapes of this repo's release assets, exactly as the Release
+ * workflow publishes them (.github/workflows/release.yml):
+ *
+ *   - compiled binaries `goodvibes-agent-<os>-<arch>` for linux/macos ×
+ *     x64/arm64 (the release tag maps darwin → "macos");
+ *   - per-platform sqlite-vec native addon ARCHIVES named
+ *     `sqlite-vec-<platform>-<arch>.tar.gz` (Node-style platform tag), each
+ *     carrying the exact layout the runtime resolves relative to the binary —
+ *     `lib/sqlite-vec-<platform>-<arch>/vec0.<suffix>`;
+ *   - one `SHA256SUMS.txt` manifest covering every asset above.
+ *
+ * The checksum manifest name and parser are the SDK's canonical ones
+ * (platform/runtime/self-update) so the agent verifies with the same
+ * mechanism every other surface uses. Asset NAMING stays local because it
+ * encodes THIS repo's release layout — the SDK's resolveArtifactNames names
+ * the TUI's `goodvibes`/`goodvibes-daemon` pair, which this repo does not
+ * ship.
+ */
+import { gunzipSync } from 'node:zlib';
+
+export { CHECKSUM_MANIFEST_NAME, parseChecksumFile } from '@pellux/goodvibes-sdk/platform/runtime/self-update';
+
+const SUPPORTED_ARCHES = new Set(['x64', 'arm64']);
+
+/**
+ * Release asset name of the compiled agent binary for a platform/arch, or
+ * null when no prebuilt binary is published for it (the release ships no
+ * Windows binary asset).
+ */
+export function resolveAgentBinaryAssetName(platform: string, arch: string): string | null {
+  if (!SUPPORTED_ARCHES.has(arch)) return null;
+  const os = platform === 'linux' ? 'linux' : platform === 'darwin' ? 'macos' : null;
+  if (!os) return null;
+  return `goodvibes-agent-${os}-${arch}`;
+}
+
+export interface SqliteVecArchiveAsset {
+  /** Release asset filename, e.g. `sqlite-vec-linux-x64.tar.gz`. */
+  readonly assetName: string;
+  /** Directory name the loader resolves, e.g. `sqlite-vec-linux-x64`. */
+  readonly dirName: string;
+  /** File the loader opens inside that directory, e.g. `vec0.so`. */
+  readonly fileName: string;
+  /** The addon file's path inside the archive (and relative to the binary): `lib/<dirName>/<fileName>`. */
+  readonly entryPath: string;
+}
+
+/**
+ * Names the sqlite-vec addon ARCHIVE for a platform/arch. Unlike the binary
+ * (whose release name maps darwin to "macos"), the archive keeps the
+ * Node-style platform tag because that is exactly what the extension loader
+ * resolves at `<execDir>/lib/sqlite-vec-<platform>-<arch>/vec0.<suffix>`.
+ */
+export function resolveSqliteVecArchive(platform: string, arch: string): SqliteVecArchiveAsset | null {
+  if (!SUPPORTED_ARCHES.has(arch)) return null;
+  const suffix = platform === 'linux' ? 'so' : platform === 'darwin' ? 'dylib' : null;
+  if (!suffix) return null;
+  const dirName = `sqlite-vec-${platform}-${arch}`;
+  const fileName = `vec0.${suffix}`;
+  return {
+    assetName: `${dirName}.tar.gz`,
+    dirName,
+    fileName,
+    entryPath: `lib/${dirName}/${fileName}`,
+  };
+}
+
+const TAR_BLOCK = 512;
+
+function readTarString(block: Buffer, offset: number, length: number): string {
+  const slice = block.subarray(offset, offset + length);
+  const nul = slice.indexOf(0);
+  return slice.toString('utf-8', 0, nul === -1 ? length : nul);
+}
+
+/**
+ * Extract one regular-file entry from a gzipped tar archive, by its exact
+ * path (a leading `./` on the archived name is tolerated). Returns the file
+ * bytes, or null when the archive holds no such entry. Throws on a gzip
+ * stream that does not decompress — a corrupted download must fail loudly,
+ * never read as "entry absent".
+ *
+ * Local on purpose: the released addon archives are flat ustar archives with
+ * short paths, so this reads the standard header fields (name, size octal,
+ * typeflag, ustar prefix) and skips everything that is not the requested
+ * regular file — no external `tar` spawn in the update path.
+ */
+export function extractTarGzEntry(archive: Buffer | Uint8Array, entryPath: string): Buffer | null {
+  const tar = gunzipSync(archive);
+  let offset = 0;
+  while (offset + TAR_BLOCK <= tar.length) {
+    const header = tar.subarray(offset, offset + TAR_BLOCK);
+    // Two consecutive zero blocks end the archive; a zero name block is enough here.
+    if (header[0] === 0) break;
+    const name = readTarString(header, 0, 100);
+    const prefix = readTarString(header, 345, 155);
+    const fullName = prefix ? `${prefix}/${name}` : name;
+    const sizeOctal = readTarString(header, 124, 12).trim();
+    const size = Number.parseInt(sizeOctal || '0', 8);
+    if (!Number.isFinite(size) || size < 0) return null;
+    const typeflag = header[156];
+    const isRegular = typeflag === 0 || typeflag === 0x30; // NUL or '0'
+    const normalized = fullName.startsWith('./') ? fullName.slice(2) : fullName;
+    const dataStart = offset + TAR_BLOCK;
+    if (isRegular && normalized === entryPath) {
+      if (dataStart + size > tar.length) return null;
+      return Buffer.from(tar.subarray(dataStart, dataStart + size));
+    }
+    offset = dataStart + Math.ceil(size / TAR_BLOCK) * TAR_BLOCK;
+  }
+  return null;
+}

package/src/runtime/services.ts

@@ -5,7 +5,7 @@ import { shell as runtimeShell } from '@pellux/goodvibes-sdk/platform/runtime';
 import type { shell as RuntimeShell } from '@pellux/goodvibes-sdk/platform/runtime';
 import { SecretsManager } from '../config/secrets.ts';
 import { readCheckpointGuardSettings, readCheckpointRegistrationSetting } from '../config/checkpoint-settings.ts';
-import { createWorkspaceRegistrationLiveChecker, migrateLegacyWorkspaceRegistryIfNeeded } from '../config/workspace-registration.ts';
+import { backfillCheckpointEligibilityIfNeeded, createWorkspaceRegistrationLiveChecker, migrateLegacyWorkspaceRegistryIfNeeded } from '../config/workspace-registration.ts';
 import { FocusTracker } from '../core/focus-tracker.ts';
 import { ServiceRegistry } from '@pellux/goodvibes-sdk/platform/config';
 import { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
@@ -21,10 +21,13 @@ import { createSessionConversationRewindPort } from './conversation-rewind-port.
 // terminal-shell does not already wrap, rather than hand-rolling the bridge.
 import { attachFleetEmitBridge } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
 import type { SharedSessionRoutingIntent } from '@pellux/goodvibes-sdk/platform/control-plane';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { computeUsageCostUsd, resolveModelReference, type ModelIdCandidate } from '@pellux/goodvibes-sdk/platform/providers';
+import { logger, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { UserPermissionRuleStore } from '@pellux/goodvibes-sdk/platform/permissions';
 import { AGENT_SPINE_PARTICIPANT, SessionSpineClient } from '@pellux/goodvibes-sdk/platform/runtime/session-spine';
 import {
   createSpineConnectionResolver,
+  createSpineReceiptConsumer,
   createSpineRestProbe,
   createSpineRestTransport,
 } from './session-spine-rest-transport.ts';
@@ -53,9 +56,12 @@ import { AgentMessageBus } from '@pellux/goodvibes-sdk/platform/agents';
 import { WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
 import { AgentOrchestrator } from '@pellux/goodvibes-sdk/platform/agents';
 import { ArchetypeLoader } from '@pellux/goodvibes-sdk/platform/agents';
-import { CodeIndexStore } from '@pellux/goodvibes-sdk/platform/state';
+import { CodeIndexStore, resolveMemoryVectorDbPath } from '@pellux/goodvibes-sdk/platform/state';
 import { CodeIndexReindexScheduler } from '@pellux/goodvibes-sdk/platform/state';
-import { createOrchestrationEngine } from '@pellux/goodvibes-sdk/platform/orchestration';
+import { createOrchestrationEngine, createProviderBackedAttemptJudge } from '@pellux/goodvibes-sdk/platform/orchestration';
+import { StoreSnapshotScheduler } from '@pellux/goodvibes-sdk/platform/state/store-snapshots';
+import { buildExecPromptAnswerHandler } from '@pellux/goodvibes-sdk/platform/runtime/permissions/exec-prompt-wiring';
+import { AgentDaemonReceiptFeed } from './daemon-receipts.ts';
 import { WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
 
 /**
@@ -120,7 +126,16 @@ import { SandboxSessionRegistry } from '@/runtime/index.ts';
 import { createShellPathService, type ShellPathService } from '@/runtime/index.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import type { FeatureFlagManager, RuntimeFoundationClientsOptions } from '@/runtime/index.ts';
-import { createFeatureFlagManager } from '@/runtime/index.ts';
+import { createFeatureFlagManager, deriveFeatureStates, bindFeatureSettingsBridge } from '@/runtime/index.ts';
+import {
+  FeatureAnnouncementStore,
+  createSandboxContainmentAnnouncer,
+  featureAnnouncementsPath,
+} from '@pellux/goodvibes-sdk/platform/runtime/feature-announcements';
+import {
+  buildLocalhostFetchApproval,
+  type LocalhostFetchApproval,
+} from '@pellux/goodvibes-sdk/platform/runtime/permissions/localhost-fetch-approval';
 import { PolicyRuntimeState } from '@/runtime/index.ts';
 import {
   createWorkflowServices,
@@ -169,40 +184,79 @@ function buildFallbackModelDefinition(provider: string, modelId: string): ModelD
   };
 }
 
-function normalizeSharedSessionModelId(modelId: string | undefined, providerId: string | undefined): string | undefined {
+/**
+ * Fork-mirror of the SDK's buildSharedSessionAgentSpawnRoutingInput
+ * (platform/control-plane/session-intents.ts — the builder itself has no
+ * public export path; only its intent types do). Bare model ids resolve
+ * through the SDK's PUBLIC shared resolver (resolveModelReference from
+ * platform/providers): unique across the registry auto-qualifies, an
+ * ambiguous id throws the real candidate registryKeys, an unknown id throws
+ * closest-match suggestions plus a concrete valid example. Keep the body
+ * faithful to the SDK's; any deliberate divergence gets its own comment.
+ */
+function normalizeSharedSessionModelId(
+  modelId: string | undefined,
+  providerId: string | undefined,
+  modelCandidates?: readonly ModelIdCandidate[],
+): string | undefined {
   const trimmedModelId = modelId?.trim();
   if (!trimmedModelId) return undefined;
   const trimmedProviderId = providerId?.trim();
   const separatorIndex = trimmedModelId.indexOf(':');
-  if (separatorIndex > 0) return trimmedModelId;
+  if (separatorIndex > 0) {
+    const modelProviderId = trimmedModelId.slice(0, separatorIndex);
+    if (trimmedProviderId && trimmedProviderId !== modelProviderId) {
+      throw new Error(`Shared-session routing model '${trimmedModelId}' conflicts with provider '${trimmedProviderId}'.`);
+    }
+    return trimmedModelId;
+  }
   if (trimmedProviderId) return `${trimmedProviderId}:${trimmedModelId}`;
-  return trimmedModelId;
+  if (modelCandidates) {
+    try {
+      return resolveModelReference(trimmedModelId, modelCandidates);
+    } catch (err) {
+      throw new Error(`Shared-session routing model: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  throw new Error(`Shared-session routing model '${trimmedModelId}' must be provider-qualified.`);
 }
 
-function normalizeSharedSessionFallbackModels(models: readonly string[] | undefined): string[] {
+function normalizeSharedSessionFallbackModels(
+  models: readonly string[] | undefined,
+  modelCandidates?: readonly ModelIdCandidate[],
+): string[] {
   return (models ?? [])
     .filter((model): model is string => typeof model === 'string' && model.trim().length > 0)
     .map((model) => {
       const trimmed = model.trim();
-      const separatorIndex = trimmed.indexOf(':');
-      if (separatorIndex <= 0 || separatorIndex === trimmed.length - 1) {
-        throw new Error(`Shared-session fallback model '${model}' must be provider-qualified.`);
+      if (trimmed.includes(':')) return trimmed;
+      if (modelCandidates) {
+        try {
+          return resolveModelReference(trimmed, modelCandidates);
+        } catch (err) {
+          throw new Error(`Shared-session fallback model: ${err instanceof Error ? err.message : String(err)}`);
+        }
       }
-      return trimmed;
+      throw new Error(`Shared-session fallback model '${model}' must be provider-qualified.`);
     });
 }
 
-function buildAgentSpawnRoutingFromSharedSession(
+/** Exported for the spawn-routing contract tests; the composition root below is the only live caller. */
+export function buildAgentSpawnRoutingFromSharedSession(
   routing: SharedSessionRoutingIntent | undefined,
-  options: { readonly restrictTools?: boolean | undefined } = {},
+  options: {
+    readonly restrictTools?: boolean | undefined;
+    /** The live registry's model candidates — enables bare model id resolution when supplied. */
+    readonly modelCandidates?: readonly ModelIdCandidate[] | undefined;
+  } = {},
 ): Partial<Parameters<AgentManager['spawn']>[0]> {
   if (!routing) return options.restrictTools ? { restrictTools: true } : {};
   const provider = routing.providerId?.trim();
-  const model = normalizeSharedSessionModelId(routing.modelId, provider);
+  const model = normalizeSharedSessionModelId(routing.modelId, provider, options.modelCandidates);
   if (provider && !model) {
     throw new Error('Shared-session provider routing requires a provider-qualified model when provider is supplied.');
   }
-  const fallbackModels = normalizeSharedSessionFallbackModels(routing.fallbackModels);
+  const fallbackModels = normalizeSharedSessionFallbackModels(routing.fallbackModels, options.modelCandidates);
   const providerFailurePolicy = routing.providerFailurePolicy ?? (
     fallbackModels.length ? 'ordered-fallbacks' : 'fail'
   );
@@ -446,8 +500,39 @@ export interface RuntimeServices extends SdkRuntimeServices {
   readonly channelDeliveryRouter: ChannelDeliveryRouter;
   readonly watcherRegistry: WatcherRegistry;
   readonly approvalBroker: ApprovalBroker;
+  /**
+   * Localhost dev-server fetch approval (ask once, persist
+   * fetch.allowLocalhost for the project) — same instance wired into the
+   * orchestrator's tool deps; bootstrap-core must replay it there.
+   */
+  readonly localhostFetchApproval: LocalhostFetchApproval;
+  /**
+   * Announce-once store for default-on feature receipts (shared per-install
+   * file under the control-plane config dir).
+   */
+  readonly featureAnnouncementStore: FeatureAnnouncementStore;
+  /**
+   * First-contained-exec-run announcer — same instance wired into the
+   * orchestrator's tool deps; bootstrap-core must replay it there.
+   */
+  readonly onSandboxedRun: () => void;
   readonly sessionBroker: SharedSessionBroker;
   readonly sessionSpineClient: SessionSpineClient;
+  /**
+   * Connected-host honesty receipts ("updated from X to Y", "restarted after
+   * a crash") captured off the spine probe's /status reads; the renderer
+   * attaches at bootstrap and every receipt is delivered exactly once.
+   */
+  readonly daemonReceiptFeed: AgentDaemonReceiptFeed;
+  /**
+   * Performs ONE receipt-consuming /status read (`?receipts=consume`) and pushes
+   * whatever the daemon delivered into {@link daemonReceiptFeed}. A current
+   * daemon delivers its one-shot honesty receipts only to a consuming read (a
+   * plain liveness /status read is receipt-neutral), so bootstrap invokes this
+   * exactly once per attach — see the memory-spine adoption reconciler's
+   * `onAttach`. Best-effort: it never throws and yields nothing on failure.
+   */
+  readonly consumeDaemonReceipts: () => Promise<void>;
   readonly deliveryManager: AutomationDeliveryManager;
   readonly automationManager: AutomationManager;
   readonly gatewayMethods: GatewayMethodCatalog;
@@ -502,7 +587,7 @@ export interface RuntimeServices extends SdkRuntimeServices {
   readonly worktreeRegistry: WorktreeRegistry;
   readonly sandboxSessionRegistry: SandboxSessionRegistry;
   readonly webhookNotifier: WebhookNotifier;
-  /** OS-level terminal focus tracker, ported from goodvibes-tui's W2.3 (core/focus-tracker.ts). */
+  /** OS-level terminal focus tracker, ported from goodvibes-tui's core/focus-tracker.ts. */
   readonly focusTracker: FocusTracker;
   readonly replayEngine: DeterministicReplayEngine;
   readonly providerOptimizer: ProviderOptimizer;
@@ -553,6 +638,13 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   });
   const configManager = options.configManager;
   const featureFlags = options.featureFlags ?? createFeatureFlagManager();
+  if (options.featureFlags === undefined) {
+    // Gate states derive from domain settings keys; the bridge keeps live
+    // config.set changes flowing. Wired only for a manager this call owns —
+    // an injected manager (bootstrap-core's) is the caller's to seed/bridge.
+    featureFlags.loadFromConfig({ flags: deriveFeatureStates(configManager) });
+    bindFeatureSettingsBridge(configManager, featureFlags);
+  }
   const runtimeDispatch = createDomainDispatch(options.runtimeStore);
   const gatewayMethods = new GatewayMethodCatalog();
   const keybindingsManager = new KeybindingsManager({
@@ -609,9 +701,16 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   });
   ensureConfiguredModelIsRoutable(providerRegistry, configManager);
   providerRegistry.initCustomProviders();
+  providerRegistry.initProviderModelDiscovery();
+  // ONE credential chain (env -> secrets -> subscription), mirroring the SDK
+  // composition root: boot applies secrets-backed keys; every secrets
+  // write/delete re-registers builtin providers LIVE (no restart needed).
+  secretsManager.onDidChange(() => void providerRegistry.refreshProviderCredentials().catch((error) => logger.warn('live credential refresh failed', { error: summarizeError(error) })));
+  void providerRegistry.refreshProviderCredentials().catch((error) => logger.warn('boot credential refresh failed', { error: summarizeError(error) }));
   const toolLLM = new ToolLLM({
     configManager,
     providerRegistry,
+    runtimeBus: options.runtimeBus,
   });
   const localUserAuthManager = options.localUserAuthManager ?? new UserAuthManager({
     bootstrapFilePath: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'auth-users.json'),
@@ -643,6 +742,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     messageBus: agentMessageBus,
     executor: agentOrchestrator,
     configManager,
+    providerRegistry,
   });
   agentManager.setRuntimeBus(options.runtimeBus);
   const wrfcController = Reflect.construct(WrfcController, [options.runtimeBus, agentMessageBus, {
@@ -662,6 +762,12 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const approvalBroker = new ApprovalBroker({
     storePath: shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'control-plane', 'approvals.json'),
   });
+  // Durable user-origin permission rules (remembered approvals), mirroring the
+  // SDK composition root: one store per project, consumed by the permission
+  // manager (bootstrap-core) and the permissions.rules.* gateway verbs below.
+  // Background init is fail-safe: a broken store means asks keep prompting.
+  const userPermissionRuleStore = new UserPermissionRuleStore(join(configManager.getControlPlaneConfigDir(), 'permission-rules.json'));
+  void userPermissionRuleStore.init().catch((error) => logger.warn('user permission rule store init failed; asks will prompt', { error: summarizeError(error) }));
   const sessionBroker = new SharedSessionBroker({
     storePath: shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'control-plane', 'sessions.json'),
     routeBindings,
@@ -677,9 +783,21 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   // starts the daemon. All calls are fire-and-forget; a down daemon degrades to
   // an honest offline queue while the local broker keeps rendering.
   const spineResolveConnection = createSpineConnectionResolver(configManager, homeDirectory);
+  const daemonReceiptFeed = new AgentDaemonReceiptFeed();
+  // The daemon's one-shot honesty receipts are delivered ONLY to an explicit
+  // `?receipts=consume` read (a plain /status read is receipt-neutral), so the
+  // liveness probe below stays plain and a SEPARATE consuming read runs once
+  // per attach (bootstrap wires this to the memory-spine reconciler's onAttach).
+  const spineReceiptConsumer = createSpineReceiptConsumer({ resolveConnection: spineResolveConnection });
+  const consumeDaemonReceipts = async (): Promise<void> => {
+    const receipts = await spineReceiptConsumer();
+    if (receipts.length > 0) daemonReceiptFeed.push(receipts);
+  };
   const sessionSpineClient = new SessionSpineClient({
     participant: AGENT_SPINE_PARTICIPANT,
     transport: createSpineRestTransport({ resolveConnection: spineResolveConnection }),
+    // Liveness only: a plain /status read that never consumes receipts. The
+    // once-per-attach consuming read above is the agent's receipt reader.
     probe: createSpineRestProbe({ resolveConnection: spineResolveConnection }),
     log: logger,
   });
@@ -687,7 +805,11 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     const record = agentManager.spawn({
       mode: 'spawn',
       task,
-      ...buildAgentSpawnRoutingFromSharedSession(input.routing, { restrictTools: true }),
+      // Spawn routing resolves through the SDK's shared model-reference
+      // resolver contract (unique-across-registry auto-qualifies; ambiguous
+      // and unknown ids throw errors naming real candidates) — the live
+      // registry's models are the candidate list.
+      ...buildAgentSpawnRoutingFromSharedSession(input.routing, { restrictTools: true, modelCandidates: providerRegistry.listModels() }),
       context: `shared-session:${input.sessionId}`,
     });
     return { agentId: record.id };
@@ -733,6 +855,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     runtimeStore: options.runtimeStore,
     runtimeBus: options.runtimeBus,
     deliveryManager,
+    providerRegistry,
     spawnTask: (input) => {
       const record = agentManager.spawn({
         mode: 'spawn',
@@ -908,8 +1031,32 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     subscriptionManager,
     secretsManager,
   });
+  // Localhost dev-server fetches ride the same broker: ask once, one-tap
+  // "allow for this project", persisted as fetch.allowLocalhost.
+  // An exec command blocked on a terminal prompt (host-key confirmation,
+  // credential ask) rides the same broker: the pending prompt surfaces through
+  // every surface's approval machinery and the typed answer feeds the same
+  // continuing run. The SDK's own wiring (public since this SDK round): the
+  // former agent-local mirror existed only because the builder had no public
+  // export path.
+  const execPromptAnswerHandler = buildExecPromptAnswerHandler({
+    requestApproval: (input) => approvalBroker.requestApproval(input),
+  });
+  const localhostFetchApproval = buildLocalhostFetchApproval({
+    requestApproval: (input) => approvalBroker.requestApproval(input),
+    configManager,
+  });
+  // Announce-once receipts for default-on features: the first contained exec
+  // run yields the one-time containment line (persisted, once per install).
+  const announcementStore = new FeatureAnnouncementStore(featureAnnouncementsPath(configManager));
+  const onSandboxedRun = createSandboxContainmentAnnouncer(announcementStore, (announcement) => {
+    logger.info(announcement.text, { announcement: announcement.id });
+  });
   agentOrchestrator.setDependencies({
     surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
+    execPromptAnswerHandler,
+    localhostFetchApproval,
+    onSandboxedRun,
     fileCache,
     projectIndex,
     workingDirectory,
@@ -959,17 +1106,43 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   //                            explicitly invoked. See the construction site
   //                            below for the full registered-workspaces-only
   //                            rule (owner ruling, 2026-07-10).
+  // Honest-unpriced: usage prices through the ONE model pricing resolver
+  // (manual -> registration -> provider-served -> catalog -> unknown; any
+  // resolvable model). Unknown/subscription yields null (costState
+  // 'unpriced'), never $0. SHARED by fleet + orchestration so totals never
+  // double-count — mirrors the SDK composition root.
+  const priceUsage = (model: string | undefined, usage: { inputTokens: number; outputTokens: number }): number | null => (model ? computeUsageCostUsd(providerRegistry.resolveModelPricing(model), usage) : null);
+
   const orchestrationEngine = createOrchestrationEngine({
     agentManager,
     configManager,
     runtimeBus: options.runtimeBus,
     projectRoot: workingDirectory,
+    priceUsage,
+    judgeAttempts: createProviderBackedAttemptJudge(providerRegistry),
   });
   const codeIndexStore = new CodeIndexStore(
     workingDirectory,
     join(workingDirectory, '.goodvibes', 'agent', 'code-index.sqlite'),
     memoryEmbeddingRegistry,
   );
+  // Data safety with no discipline: a daily snapshot of every SQLite store
+  // this runtime writes, bounded retention, unref'd timers — the SDK's own
+  // StoreSnapshotScheduler (public since this SDK round; the former agent-local
+  // mirror and its local pruning engine existed only because the class and
+  // RetentionPolicy/SnapshotPruner had no public export path). The canonical
+  // memory db is shared with the daemon/TUI; the shared snapshot layout means
+  // whichever process sweeps first writes that day's copy. The agent's code
+  // index is deliberately inert (see the block comment above) — its entry is a
+  // no-op until a file actually exists.
+  const storeSnapshotScheduler = new StoreSnapshotScheduler({
+    stores: [
+      { name: 'memory store', dbPath: memoryDbPath },
+      { name: 'memory vector index', dbPath: resolveMemoryVectorDbPath(memoryDbPath) },
+      { name: 'code index store', dbPath: join(workingDirectory, '.goodvibes', 'agent', 'code-index.sqlite') },
+    ],
+  });
+  storeSnapshotScheduler.start();
   const codeIndexReindexScheduler = new CodeIndexReindexScheduler({
     target: codeIndexStore,
     workingDirectory,
@@ -993,6 +1166,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     messageBus: agentMessageBus,
     automationManager,
     runtimeBus: options.runtimeBus,
+    priceUsage,
   });
   // Root/retention guard options come from the user's `checkpoints.*` settings
   // (see config/checkpoint-settings.ts); any key the user did not set is omitted
@@ -1032,6 +1206,17 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   if (registrationMigration) {
     logger.info('Migrated the local workspace registry into the shared registration store', { ...registrationMigration });
   }
+  // After the import migration (records now in the shared store), stamp the ones
+  // that came from the agent's OWN explicit list as checkpoint-eligible, so the
+  // eligibility boundary below does not retroactively drop workspaces the owner
+  // had already opted into checkpoints. Runs once (receipt-gated); derives the
+  // explicit set from the still-present legacy registry file. Records lacking the
+  // flag (a TUI first-open self-record) stay ineligible — the boundary the owner
+  // ruled stays explicit.
+  const eligibilityBackfill = backfillCheckpointEligibilityIfNeeded(shellPaths);
+  if (eligibilityBackfill && eligibilityBackfill.recordsStamped > 0) {
+    logger.info('Marked the agent\'s explicitly-registered workspaces checkpoint-eligible', { ...eligibilityBackfill });
+  }
   const checkpointsRegistrationStatus = createWorkspaceRegistrationLiveChecker(shellPaths, workingDirectory);
   const checkpointsCurrentlyAllowed = (): boolean =>
     checkpointsRegistrationStatus() === 'covered' || readCheckpointRegistrationSetting(configManager) === 'guarded';
@@ -1142,6 +1327,23 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     sessionBroker,
     secretsManager,
     approvalBroker,
+    // The generic broker ask seam (rounds 4-6): CI-watch red runs raise a
+    // "fix this?" offer through the same approval machinery as every ask.
+    requestApproval: (input) => approvalBroker.requestApproval(input),
+    // Recurring CI polling over the same watcher framework the fleet rows
+    // already observe; degrades honestly to the manual verb when watchers
+    // are disabled (the SDK registrar checks watchers.enabled itself).
+    watcherRegistry,
+    // permissions.rules.list/.delete over the durable remembered-approval
+    // rules constructed above.
+    userPermissionRuleStore,
+    // Completion push source (rounds 4-6) plus the needs-input source ride
+    // the runtime bus's fleet domain. DELIBERATE DIVERGENCE from the SDK
+    // composition root: no sessionPresence is passed — the SDK builds its
+    // isAttached check from hasFreshSurfaceParticipant, which has no public
+    // export path. Absent presence means every needs-input block pushes
+    // (the SDK-documented fallback), never a missed notification.
+    runtimeBus: options.runtimeBus,
     shellPaths,
     configManager,
     runtimeStore: options.runtimeStore,
@@ -1212,6 +1414,8 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     orchestrationEngine,
     codeIndexStore,
     codeIndexReindexScheduler,
+    storeSnapshotScheduler,
+    userPermissionRuleStore,
     processRegistry,
     workspaceCheckpointManager,
     runtimeBus: options.runtimeBus,
@@ -1225,8 +1429,13 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     channelDeliveryRouter,
     watcherRegistry,
     approvalBroker,
+    localhostFetchApproval,
+    featureAnnouncementStore: announcementStore,
+    onSandboxedRun,
     sessionBroker,
     sessionSpineClient,
+    daemonReceiptFeed,
+    consumeDaemonReceipts,
     deliveryManager,
     automationManager,
     gatewayMethods,