@pellux/goodvibes-sdk 0.37.2 → 1.0.0

package/dist/platform/runtime/services.js

@@ -8,7 +8,7 @@ import { SubscriptionManager } from '../config/subscriptions.js';
 import { AutomationDeliveryManager, AutomationManager, AutomationRouteStore } from '../automation/index.js';
 import { ChannelPluginRegistry, ChannelPolicyManager, RouteBindingManager, SurfaceRegistry } from '../channels/index.js';
 import { ChannelDeliveryRouter } from '../channels/delivery-router.js';
-import { ApprovalBroker, GatewayMethodCatalog, SharedSessionBroker } from '../control-plane/index.js';
+import { ApprovalBroker, GatewayMethodCatalog, SharedSessionBroker, registerW3S2GatewayMethods } from '../control-plane/index.js';
 import { buildSharedSessionAgentSpawnRoutingInput } from '../control-plane/session-intents.js';
 import { WatcherRegistry } from '../watchers/index.js';
 import { ArtifactStore } from '../artifacts/index.js';
@@ -27,6 +27,8 @@ import { FileUndoManager } from '../state/file-undo.js';
 import { WorkspaceCheckpointManager } from '../workspace/checkpoint/index.js';
 import { MemoryRegistry } from '../state/memory-registry.js';
 import { MemoryStore } from '../state/memory-store.js';
+import { CodeIndexStore } from '../state/code-index-store.js';
+import { CodeIndexReindexScheduler } from '../state/code-index-reindex.js';
 import { createDomainDispatch } from './store/index.js';
 import { DistributedRuntimeManager } from './remote/distributed-runtime-manager.js';
 import { RemoteRunnerRegistry, RemoteSupervisor } from './remote/index.js';
@@ -72,6 +74,8 @@ import { PolicyRuntimeState } from './permissions/policy-runtime.js';
 import { requireSurfaceRoot } from './surface-root.js';
 import { createNoopKeybindingsManager, createNoopPanelManager, } from './host-ui.js';
 import { createWorkflowServices, } from '../tools/workflow/index.js';
+import { createProcessRegistry } from './fleet/index.js';
+import { createOrchestrationEngine } from '../orchestration/index.js';
 export function bindProviderOptimizerFeatureFlag(featureFlags, providerOptimizer) {
     providerOptimizer.setEnabled(featureFlags.isEnabled('provider-optimizer'));
     return featureFlags.subscribe((flagId, state) => {
@@ -172,6 +176,20 @@ export function createRuntimeServices(options) {
         executor: agentOrchestrator,
         configManager,
     });
+    // Wave-3 Part C6 bridge: AgentOrchestrator is constructed before
+    // AgentManager exists, so the conversation-snapshot sink is wired here via
+    // setConversationSink rather than as a constructor dependency (same
+    // ordering constraint as setRuntimeBus above).
+    agentOrchestrator.setConversationSink({
+        register: (agentId, source) => agentManager.registerConversationSource(agentId, source),
+        release: (agentId) => agentManager.releaseConversationSource(agentId),
+    });
+    // Wave-4 cooperative cancellation bridge (wo701): same ordering constraint
+    // and setter pattern as setConversationSink above — AgentOrchestrator is
+    // constructed before AgentManager exists.
+    agentOrchestrator.setCancellationSource({
+        get: (agentId) => agentManager.getCancellationSignal(agentId),
+    });
     agentManager.setRuntimeBus(options.runtimeBus);
     const wrfcController = new WrfcController(options.runtimeBus, agentMessageBus, {
         agentManager,
@@ -189,8 +207,9 @@ export function createRuntimeServices(options) {
     const approvalBroker = new ApprovalBroker({
         storePath: shellPaths.resolveProjectPath(surfaceRoot, 'control-plane', 'approvals.json'),
     });
+    // ONE home-scoped durable session store; project is DATA on each record.
     const sessionBroker = new SharedSessionBroker({
-        storePath: shellPaths.resolveProjectPath(surfaceRoot, 'control-plane', 'sessions.json'),
+        storePath: options.sessionStorePath ?? shellPaths.resolveUserPath('control-plane', 'sessions.json'),
         routeBindings,
         agentStatusProvider: agentManager,
         messageSender: agentMessageBus,
@@ -211,6 +230,25 @@ export function createRuntimeServices(options) {
         embeddingRegistry: memoryEmbeddingRegistry,
     });
     const memoryRegistry = new MemoryRegistry(memoryStore);
+    // Repo source-tree code index (Wave-5 wo802, W5.3 Stage A) — shares
+    // memoryEmbeddingRegistry so code + memory embeddings use one provider and
+    // one dimensionality. Schema init only; build is not auto-triggered here
+    // (see the RuntimeServices.codeIndexStore doc comment).
+    const codeIndexDbPath = join(workingDirectory, '.goodvibes', surfaceRoot, 'code-index.sqlite');
+    const codeIndexStore = new CodeIndexStore(workingDirectory, codeIndexDbPath, memoryEmbeddingRegistry);
+    codeIndexStore.init();
+    if (options.autoStartCodeIndex) {
+        codeIndexStore.scheduleBuild();
+    }
+    // Wave-5 Stage B: tool-site incremental reindex. Gated on the SDK's autoStartCodeIndex opt-in
+    // (this library's storage.codeIndexEnabled analog) AND the built-state check inside the
+    // scheduler — an unbuilt index is a no-op either way.
+    const codeInjectionSettingEnabled = () => options.autoStartCodeIndex === true;
+    const codeIndexReindexScheduler = new CodeIndexReindexScheduler({
+        target: codeIndexStore,
+        workingDirectory,
+        isEnabled: codeInjectionSettingEnabled,
+    });
     const deliveryManager = new AutomationDeliveryManager({
         configManager,
         secretsManager,
@@ -422,6 +460,9 @@ export function createRuntimeServices(options) {
         remoteRunnerRegistry,
         knowledgeService,
         memoryRegistry,
+        codeIndex: codeIndexStore,
+        isCodeInjectionSettingEnabled: codeInjectionSettingEnabled,
+        codeIndexReindexScheduler,
         archetypeLoader,
         configManager,
         providerRegistry,
@@ -435,6 +476,50 @@ export function createRuntimeServices(options) {
         sandboxSessionRegistry,
         workflowServices: workflow,
     });
+    // Honest-unpriced: only price models the catalog actually knows; an
+    // unknown model yields null (costState 'unpriced'), never a fabricated $0.
+    // SHARED between the fleet registry and the orchestration engine — the
+    // single cost source of truth so budget checks and fleet cost totals can
+    // never double-count against each other.
+    const priceUsage = (model, usage) => {
+        if (!model)
+            return null;
+        const catalogModels = providerRegistry.getRawCatalogModels();
+        const known = catalogModels.some((entry) => model === entry.id || model.startsWith(entry.id) || model.includes(entry.id));
+        if (!known && !model.endsWith(':free'))
+            return null;
+        const pricing = providerRegistry.getCostFromCatalog(model);
+        return (usage.inputTokens * pricing.input + usage.outputTokens * pricing.output) / 1_000_000;
+    };
+    // Orchestration engine (Wave 4, wo701) — ships alongside wrfcController, untouched by this change. See the RuntimeServices interface comment.
+    const orchestrationEngine = createOrchestrationEngine({
+        agentManager,
+        configManager,
+        runtimeBus: options.runtimeBus,
+        projectRoot: workingDirectory,
+        priceUsage,
+    });
+    // Live process registry (W2.1) — narrow structural deps only, constructed
+    // after every source manager exists. See the RuntimeServices interface
+    // comment for the dispose story (no RuntimeServices-wide shutdown seam yet).
+    const processRegistry = createProcessRegistry({
+        agentManager,
+        wrfcController,
+        orchestrationEngine,
+        processManager,
+        watcherRegistry,
+        workflow: {
+            workflowManager: workflow.workflowManager,
+            triggerManager: workflow.triggerManager,
+            scheduleManager: workflow.scheduleManager,
+        },
+        approvalBroker,
+        sessionBroker,
+        runtimeBus: options.runtimeBus,
+        priceUsage,
+        codeIndexService: codeIndexStore,
+    });
+    registerW3S2GatewayMethods(gatewayMethods, { processRegistry, workspaceCheckpointManager, sessionBroker }); // W3-S2 (routes/register-w3-s2.ts)
     return {
         workingDirectory,
         homeDirectory,
@@ -463,6 +548,8 @@ export function createRuntimeServices(options) {
         projectPlanningService,
         memoryStore,
         memoryRegistry,
+        codeIndexStore,
+        codeIndexReindexScheduler,
         serviceRegistry,
         secretsManager,
         subscriptionManager,
@@ -515,7 +602,9 @@ export function createRuntimeServices(options) {
         agentMessageBus,
         agentOrchestrator,
         wrfcController,
+        orchestrationEngine,
         processManager,
+        processRegistry,
         modeManager,
         fileUndoManager,
         workspaceCheckpointManager,
@@ -524,6 +613,10 @@ export function createRuntimeServices(options) {
             // Step 1: Re-root MemoryStore — close existing SQLite/vector handles, reopen at new path.
             const newMemoryDbPath = join(newWorkingDir, '.goodvibes', surfaceRoot, 'memory.sqlite');
             await memoryStore.reroot(newMemoryDbPath);
+            // Step 1b: Re-root the code index alongside memory — otherwise it keeps
+            // pointing at the old tree after a workspace swap (Wave-5 wo802 risk #7).
+            const newCodeIndexDbPath = join(newWorkingDir, '.goodvibes', surfaceRoot, 'code-index.sqlite');
+            await codeIndexStore.reroot(newWorkingDir, newCodeIndexDbPath);
             // Step 2: Re-root ProjectIndex — flush current path, reset, load from new directory.
             await projectIndex.reroot(newWorkingDir);
             // Step 3: Subsystems that cannot be live-rerooted emit a warn log.

package/dist/platform/runtime/session-spine/client.d.ts

@@ -0,0 +1,234 @@
+/**
+ * client.ts — the SDK session-spine surface client.
+ *
+ * The in-process coordinator that mirrors a surface's OWN session identity
+ * (create / resume / heartbeat / close) into the daemon-hosted session spine.
+ * It sits NEXT TO a surface's local session truth, never replacing it: the local
+ * store stays the offline read-model; this client mirrors identity to the daemon
+ * and buffers ops when the daemon is unreachable.
+ *
+ * This is the ONE core extracted from two near-twin implementations — the TUI's
+ * typed-client version (`goodvibes-tui` src/runtime/session-spine-client.ts) and
+ * the agent's raw-REST version (`goodvibes-agent` src/runtime/session-spine-client.ts).
+ * The union of their behaviors is the spec; their differences are parameterized:
+ *
+ *  - TRANSPORT is injected. The core builds a canonical
+ *    {@link RegisterSharedSessionInput} and hands it to an injected
+ *    {@link SpineTransport}; the adapter performs the real wire call (a typed SDK
+ *    sessions client, or a hand-rolled version-tolerant REST mirror) and folds its
+ *    result into a {@link SpineResult}. The core NEVER assumes a typed client
+ *    exists — that is exactly why the agent, which compiles against a pinned npm
+ *    SDK that may predate `sessions.register`, can still use this core.
+ *  - ACTIVATION MODE is optional. Construct WITH a `transport` for
+ *    live-immediately mode (the agent — live for the whole process lifetime), or
+ *    WITHOUT one for dormant-until-`activate()` mode (the TUI — activated once its
+ *    bootstrap adopts a compatible external daemon, deactivated when the mode is
+ *    lost).
+ *  - PARTICIPANT identity, origin `kind`, queue bound and heartbeat window are
+ *    options with the verified defaults.
+ *
+ * Discipline (load-bearing for the interactive-latency budget):
+ *  - Every public method (register / reopen / heartbeat / close /
+ *    foldLegacyRecords) is fire-and-forget: it returns `void` SYNCHRONOUSLY and
+ *    never throws into the caller, even when the wire call rejects. Session
+ *    start/resume/heartbeat never block the render or turn path.
+ *  - Before a transport is attached every op is queued, never dropped-on-the-floor
+ *    and never attempted over a transport that does not exist. Attaching flushes
+ *    the backlog.
+ *  - Offline ops go into a bounded ring (drop-oldest); flush is idempotent because
+ *    register is an upsert.
+ *  - Heartbeat is debounced/coalesced to at most one wire call per window and omits
+ *    the title so it never renames a titled session.
+ *  - A timer-driven keepalive fires the heartbeat on a fixed cadence INDEPENDENT of
+ *    render/turn activity, so a live-but-idle surface keeps its participant
+ *    lastSeenAt fresh and never falls outside the daemon's freshness/reaper windows.
+ */
+import { logger } from '../../utils/logger.js';
+import type { RegisterSharedSessionInput, SharedSessionKind, SharedSessionParticipant } from '../../control-plane/index.js';
+/**
+ * The canonical TUI participant (TRANSPORT axis). Pass as the `participant` option
+ * when the surface is the operator terminal UI.
+ */
+export declare const TUI_SPINE_PARTICIPANT: Omit<SharedSessionParticipant, 'lastSeenAt'>;
+/**
+ * The canonical agent participant (TRANSPORT axis). `surfaceKind` stays 'service';
+ * the record origin `kind` ('agent') is stamped by the REST mirror server-side, not
+ * here — so the agent leaves `recordKind` unset.
+ */
+export declare const AGENT_SPINE_PARTICIPANT: Omit<SharedSessionParticipant, 'lastSeenAt'>;
+/** Honest reachability posture derived from this client's own wire attempts. */
+export type SpineReachability = 'unknown' | 'online' | 'offline';
+/**
+ * Outcome of a single injected-transport op, folding the two real backends' result
+ * vocabularies into one common core:
+ *  - `'ok'`       — the daemon applied it. Reachability → online; flush the queue.
+ *  - `'offline'`  — a transient connectivity fault (host unreachable). Reachability
+ *                   → offline; enqueue for idempotent replay on reconnect.
+ *  - `'rejected'` — a DURABLE refusal (auth required / route missing / server error).
+ *                   NOT a connectivity fault: logged, NEVER enqueued (so it can't
+ *                   retry-forever), reachability left unchanged.
+ */
+export type SpineOutcome = 'ok' | 'offline' | 'rejected';
+export interface SpineResult {
+    readonly outcome: SpineOutcome;
+    readonly error?: string | undefined;
+}
+/**
+ * The injected async transport. Structurally satisfied by a thin adapter over the
+ * SDK's typed HTTP sessions client (TUI) or over a hand-rolled REST mirror (agent).
+ * The core only ever calls these two methods and reads the folded {@link SpineResult}.
+ */
+export interface SpineTransport {
+    register(input: RegisterSharedSessionInput): Promise<SpineResult>;
+    close(sessionId: string): Promise<SpineResult>;
+}
+export interface SessionSpineRecord {
+    readonly sessionId: string;
+    readonly project: string;
+    readonly title?: string | undefined;
+    readonly userId?: string | undefined;
+}
+type SpineLogger = Pick<typeof logger, 'debug' | 'info'>;
+export interface SessionSpineClientOptions {
+    /**
+     * The participant identity stamped onto every register/heartbeat (TRANSPORT axis).
+     * Required — each surface passes its own (e.g. {@link TUI_SPINE_PARTICIPANT} /
+     * {@link AGENT_SPINE_PARTICIPANT}).
+     */
+    readonly participant: Omit<SharedSessionParticipant, 'lastSeenAt'>;
+    /**
+     * Attach the transport at construction for LIVE-IMMEDIATELY mode (the agent is
+     * live for the whole process lifetime). Omit for DORMANT-UNTIL-`activate()` mode
+     * (the TUI activates once its bootstrap adopts a compatible external daemon).
+     */
+    readonly transport?: SpineTransport | undefined;
+    /**
+     * Origin record `kind` stamped into every built input. The TUI stamps `'tui'`;
+     * the agent leaves it unset (its REST mirror stamps `'agent'` server-side).
+     */
+    readonly recordKind?: SharedSessionKind | undefined;
+    /**
+     * Optional reachability probe backing {@link SessionSpineClient.probeReachability}
+     * (the agent's deferred-startup GET /status). Returns true when the host answered.
+     * Omitted for the TUI (whose reachability rides its wire calls). Runs OFF the
+     * interactive path.
+     */
+    readonly probe?: (() => Promise<boolean>) | undefined;
+    readonly now?: () => number;
+    readonly queueLimit?: number;
+    readonly heartbeatMinIntervalMs?: number;
+    readonly log?: SpineLogger;
+}
+export declare class SessionSpineClient {
+    private readonly participant;
+    private readonly recordKind;
+    private readonly probeImpl;
+    private readonly now;
+    private readonly queueLimit;
+    private readonly heartbeatMinIntervalMs;
+    private readonly log;
+    private transport;
+    private reachability;
+    private readonly records;
+    private readonly queue;
+    private lastHeartbeatAt;
+    private heartbeatTimer;
+    private flushing;
+    /** The most recently registered/reopened session — the keepalive heartbeat target. */
+    private lastSessionId;
+    /**
+     * Timer-driven keepalive: fires the heartbeat on a fixed cadence INDEPENDENT of
+     * render/turn activity, so a live-but-render-silent surface keeps its participant
+     * lastSeenAt fresh. Each tick is just a heartbeat() call, so it rides the SAME
+     * bounded offline-queue/reconnect handling as every other op — no new retry loop,
+     * no faster-than-cadence attempts against a dead daemon.
+     */
+    private keepaliveTimer;
+    constructor(options: SessionSpineClientOptions);
+    /** Honest reachability: 'unknown' until a wire call resolves, then online/offline. */
+    status(): SpineReachability;
+    /** Whether a transport is currently attached. */
+    get active(): boolean;
+    /** Current bounded offline-queue depth (for diagnostics / tests). */
+    get pendingOps(): number;
+    /** The session the keepalive heartbeat currently targets (diagnostics/tests). */
+    get keepaliveSessionId(): string | null;
+    /**
+     * The CANONICAL "which wire rows are mine" set: every sessionId this client
+     * has register()/reopen()'d and not yet close()'d, regardless of whatever id
+     * a caller's own local store separately uses for the same conceptual
+     * session. register()/reopen() send exactly the `sessionId` the caller
+     * passes in — this client never assumes that string also matches a local
+     * broker's own idea of the session's id. A cross-surface read facade (the
+     * SDK's SessionUnionCache) uses this to recognize its own wire mirror by
+     * the id ACTUALLY SENT, not by hoping a local reader's id happens to agree.
+     */
+    get mirroredSessionIds(): ReadonlySet<string>;
+    /**
+     * DORMANT-MODE activation: attach the transport once a compatible external daemon
+     * has been adopted. Flushes anything queued while dormant, starts the keepalive.
+     * Reachability stays 'unknown' until the first wire call resolves.
+     */
+    activate(transport: SpineTransport): void;
+    /**
+     * Detach the transport (daemon mode resolved to non-external, or was lost). Ops
+     * continue to be queued (bounded, drop-oldest) rather than dropped.
+     */
+    deactivate(reason: string): void;
+    /** CREATE: fire-and-forget initial registration (title stamped once). */
+    register(record: SessionSpineRecord): void;
+    /** RESUME: fire-and-forget reopen (reopen:true, no title) — the only reopen path. */
+    reopen(record: SessionSpineRecord): void;
+    /**
+     * HEARTBEAT: debounced re-register, coalesced to one wire call per window, no title,
+     * no reopen. Safe to call on every turn/render tick — internally a no-op unless the
+     * window has elapsed.
+     */
+    heartbeat(sessionId: string): void;
+    /** CLOSE: best-effort, fire-and-forget; tolerate a racing daemon stop. */
+    close(sessionId: string): void;
+    /**
+     * LEGACY FOLD: register each per-project record; a record whose id is in `closedIds`
+     * is registered then closed so a locally-closed session STAYS closed in the daemon
+     * (honest history). Idempotent — register is an upsert; closing an already-closed
+     * record is a no-op.
+     */
+    foldLegacyRecords(records: readonly SessionSpineRecord[], closedIds: ReadonlySet<string>): void;
+    /** Reachability probe — runs OFF the interactive path (deferred startup). Flushes on
+     * success. A no-op returning the current status when no `probe` option was supplied. */
+    probeReachability(): Promise<SpineReachability>;
+    /** Clears the pending heartbeat + keepalive timers; call on shutdown. */
+    dispose(): void;
+    private startKeepalive;
+    private stopKeepalive;
+    private cacheHeartbeatRecord;
+    private buildInput;
+    private withFreshLastSeen;
+    private dispatchRegister;
+    private runRegister;
+    private runClose;
+    private enqueue;
+    private flush;
+}
+export interface FoldLegacySpineStoreOptions {
+    readonly storePath: string;
+    readonly markerPath: string;
+    readonly project: string;
+    readonly now?: () => number;
+    readonly log?: SpineLogger;
+}
+export interface FoldLegacySpineStoreResult {
+    readonly folded: number;
+    readonly skipped: boolean;
+}
+/**
+ * Reads a surface's OWN project-scoped control-plane sessions.json and folds each
+ * record into the daemon via the client (register upsert; closed records also
+ * closed). Writes a marker file so subsequent runs are a no-op. Register is
+ * idempotent, so even a marker-less re-run is safe. Only folds the store for the
+ * project it is invoked from — the per-project discovery scope is documented, not
+ * silently "complete" across every project a surface has ever run in.
+ */
+export declare function foldLegacySpineStore(client: Pick<SessionSpineClient, 'foldLegacyRecords'>, options: FoldLegacySpineStoreOptions): FoldLegacySpineStoreResult;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/platform/runtime/session-spine/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/session-spine/client.ts"],"names":[],"mappings":"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"}