@pellux/goodvibes-sdk 0.36.0 → 0.37.1

package/dist/platform/workspace/checkpoint/side-git.js

@@ -0,0 +1,264 @@
+/**
+ * side-git.ts
+ *
+ * SideGitRunner — a hidden git repository ("side repo") whose object store
+ * (GIT_DIR) lives under <workspaceRoot>/.goodvibes/checkpoints/git while its
+ * GIT_WORK_TREE is the live workspace itself.
+ *
+ * This is the dotfiles-bare-repo trick (`git --git-dir=X --work-tree=Y`):
+ * git tracks arbitrary files in Y using an object store rooted at X,
+ * completely independent of whatever real .git directory Y may or may not
+ * already have. It gives us, for free:
+ *   - content-addressed, deduped storage (unchanged files cost ~nothing)
+ *   - `git diff` / `git diff --stat` between any two snapshots
+ *   - whole-tree restore via `read-tree` + `checkout-index`
+ *   - correct behavior in a workspace that is NOT itself a git repo
+ *
+ * DO NOT reuse GitService (../../git/service.ts) for this: it binds a single
+ * baseDir with no GIT_DIR support, and it fires Pre/Post hook events on
+ * every commit/add — automatic silent snapshots must never trigger a user's
+ * PreCommit/PostCommit hooks. AgentWorktree (../../agents/worktree.ts) already
+ * proves the `simpleGit(...).raw([...])` + explicit env pattern used here.
+ *
+ * Checkpoints are addressed entirely through our own ref namespace
+ * (refs/goodvibes/checkpoints/<id>) and through commit objects created via
+ * `commit-tree`, never through the side repo's HEAD/branch. There is no
+ * meaningful "current branch" in this design — parent/lineage is tracked in
+ * the manifest (manager.ts), not via git HEAD — so there is nothing to leave
+ * "detached" and no branch state to pollute.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { simpleGit } from 'simple-git';
+import { logger } from '../../utils/logger.js';
+import { summarizeError } from '../../utils/error-display.js';
+/** Git's well-known empty-tree object hash, valid in every repository. */
+export const EMPTY_TREE_HASH = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+/** Ref namespace all workspace checkpoints live under. */
+export const CHECKPOINT_REF_PREFIX = 'refs/goodvibes/checkpoints/';
+/** Fallback identity used for checkpoint commits so this never depends on the user's global git config. */
+const FALLBACK_IDENTITY = { name: 'GoodVibes Checkpoints', email: 'checkpoints@goodvibes.local' };
+/**
+ * Environment variable names that simple-git's built-in vulnerability scanner
+ * treats as unsafe (it would otherwise throw on every raw call rather than
+ * risk spawning an interactive editor/pager/askpass/proxy). We never need
+ * any of these — every commit here is created via `commit-tree -m <message>`,
+ * never a bare `commit`/`rebase -i`/`merge` — so stripping them from the
+ * inherited environment we pass through is both safe and avoids depending on
+ * simple-git's `unsafe.allowUnsafe*` escape hatches (not part of this
+ * package version's public option types).
+ */
+const UNSAFE_GIT_ENV_KEYS = new Set([
+    'editor',
+    'git_editor',
+    'git_sequence_editor',
+    'git_askpass',
+    'ssh_askpass',
+    'git_config',
+    'git_config_global',
+    'git_config_system',
+    'git_config_count',
+    'git_exec_path',
+    'git_external_diff',
+    'git_pager',
+    'pager',
+    'git_proxy_command',
+    'git_template_dir',
+    'git_ssh',
+    'git_ssh_command',
+    'prefix',
+]);
+/** Copy `env`, dropping keys (case-insensitively) that simple-git's vulnerability scanner blocks by default. */
+function sanitizeGitEnv(env) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (UNSAFE_GIT_ENV_KEYS.has(key.toLowerCase()))
+            continue;
+        sanitized[key] = value;
+    }
+    return sanitized;
+}
+/**
+ * Thin runner around a `simple-git` instance permanently scoped (via `.env()`)
+ * to an isolated GIT_DIR/GIT_WORK_TREE pair. Every method here is a small,
+ * named wrapper around a raw git invocation — no hook emission, no shared
+ * state with the user's real repository.
+ */
+export class SideGitRunner {
+    workspaceRoot;
+    gitDir;
+    git;
+    constructor(opts) {
+        this.workspaceRoot = opts.workspaceRoot;
+        this.gitDir = opts.gitDir;
+        this.git = simpleGit({ baseDir: opts.workspaceRoot }).env({
+            ...sanitizeGitEnv(process.env),
+            GIT_DIR: opts.gitDir,
+            GIT_WORK_TREE: opts.workspaceRoot,
+        });
+    }
+    /** Run an arbitrary raw git command against the side repo, returning stdout. */
+    async raw(args) {
+        return this.git.raw(args);
+    }
+    /**
+     * Idempotently initialize the side repo: `git init` the GIT_DIR if it does
+     * not already look initialized, set a local (side-repo-only) fallback
+     * identity so commits never depend on the user's global git config, and
+     * ensure `.goodvibes` is gitignored from the user's own repo's perspective.
+     */
+    async init() {
+        if (!existsSync(this.gitDir)) {
+            mkdirSync(this.gitDir, { recursive: true });
+        }
+        const alreadyInit = existsSync(join(this.gitDir, 'HEAD'));
+        if (!alreadyInit) {
+            await this.git.raw(['init', '--quiet']);
+            logger.debug('SideGitRunner.init: initialized side repo', { gitDir: this.gitDir });
+        }
+        // Local (side-repo-scoped) identity — never touches the user's ~/.gitconfig
+        // or the workspace's real .git/config (there is no --global here, and
+        // GIT_DIR points at our own directory, so `git config` without --global
+        // writes to <gitDir>/config).
+        await this.git.raw(['config', 'user.name', FALLBACK_IDENTITY.name]);
+        await this.git.raw(['config', 'user.email', FALLBACK_IDENTITY.email]);
+        this.ensureGoodvibesIgnored();
+    }
+    /**
+     * Ensure `<workspaceRoot>/.goodvibes/.gitignore` contains a bare `*` line so
+     * the side repo's own storage (and every other tool's state under
+     * `.goodvibes`) is invisible to the user's OWN git repo (if any). Without
+     * this, `git status`/`git add -A` in the user's real repo would see our
+     * GIT_DIR as an untracked directory and could accidentally stage it.
+     *
+     * This intentionally only ever writes inside `.goodvibes/` — it never
+     * touches the workspace's own top-level `.gitignore`.
+     */
+    ensureGoodvibesIgnored() {
+        const goodvibesDir = join(this.workspaceRoot, '.goodvibes');
+        const ignorePath = join(goodvibesDir, '.gitignore');
+        if (!existsSync(goodvibesDir)) {
+            mkdirSync(goodvibesDir, { recursive: true });
+        }
+        try {
+            if (!existsSync(ignorePath)) {
+                writeFileSync(ignorePath, '*\n', 'utf-8');
+                return;
+            }
+            const existing = readFileSync(ignorePath, 'utf-8');
+            const hasIgnoreAll = existing.split('\n').some((line) => line.trim() === '*');
+            if (!hasIgnoreAll) {
+                writeFileSync(ignorePath, `${existing.replace(/\s*$/, '')}\n*\n`, 'utf-8');
+            }
+        }
+        catch (err) {
+            logger.warn('SideGitRunner.ensureGoodvibesIgnored: failed to write .goodvibes/.gitignore', {
+                error: summarizeError(err),
+            });
+        }
+    }
+    /**
+     * Stage changes into the side index.
+     *
+     * @param paths When provided (non-empty), stage only these pathspecs
+     * (scoped snapshot). Otherwise sweep the whole work tree, always excluding
+     * `.goodvibes` (our own storage) via pathspec magic — the same
+     * `:(exclude)` pattern AgentWorktree already uses for the same reason.
+     * Beyond that exclusion, git's normal `.gitignore` handling already applies
+     * here: `.gitignore` matching is a work-tree-relative feature of git and
+     * works identically regardless of where GIT_DIR points, so the workspace's
+     * own `.gitignore` (node_modules, build output, etc.) is honored with no
+     * extra configuration.
+     */
+    async stageAll(paths) {
+        const pathspecs = paths && paths.length > 0
+            ? paths
+            : ['.', ':(exclude).goodvibes', ':(exclude).goodvibes/**'];
+        await this.git.raw(['add', '-A', '--', ...pathspecs]);
+    }
+    /** Write the currently-staged index out as a tree object, without committing. Returns the tree hash. */
+    async writeTree() {
+        return (await this.git.raw(['write-tree'])).trim();
+    }
+    /** Resolve `<commit>^{tree}` for an existing commit hash. */
+    async treeOf(commit) {
+        return (await this.git.raw(['rev-parse', `${commit}^{tree}`])).trim();
+    }
+    /**
+     * Create a commit object from a tree, deliberately WITHOUT a git parent
+     * (no `-p`) and WITHOUT moving any branch/HEAD.
+     *
+     * Checkpoint lineage is tracked exclusively via the manifest's `parentId`
+     * field (manager.ts) — never via git ancestry. This isn't just a style
+     * choice: if checkpoint commits chained via `-p` the way a normal git
+     * history does, deleting an OLD checkpoint's ref in `gc()` would free
+     * nothing, because that commit stays reachable through every NEWER
+     * checkpoint's parent pointer — the ref is gone but the commit (and any
+     * tree/blob objects unique to it) is still walkable from every surviving
+     * descendant. Parentless commits mean a checkpoint's own ref is the ONLY
+     * thing keeping its commit reachable, so once that ref is deleted,
+     * `git gc --prune=now` can genuinely reclaim it.
+     *
+     * The returned hash is only reachable once a ref is pointed at it via
+     * `updateRef`.
+     */
+    async commitTree(treeHash, message) {
+        return (await this.git.raw(['commit-tree', treeHash, '-m', message])).trim();
+    }
+    async updateRef(refName, commit) {
+        await this.git.raw(['update-ref', refName, commit]);
+    }
+    async deleteRef(refName) {
+        await this.git.raw(['update-ref', '-d', refName]);
+    }
+    /** List every ref under CHECKPOINT_REF_PREFIX as `{ id, commit }`. */
+    async listCheckpointRefs() {
+        let out;
+        try {
+            out = await this.git.raw(['for-each-ref', '--format=%(refname) %(objectname)', CHECKPOINT_REF_PREFIX]);
+        }
+        catch {
+            return [];
+        }
+        return out
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => {
+            const [refName, commit] = line.split(' ');
+            const id = (refName ?? '').slice(CHECKPOINT_REF_PREFIX.length);
+            return { id, commit: commit ?? '' };
+        })
+            .filter((entry) => entry.id.length > 0 && entry.commit.length > 0);
+    }
+    /** Files tracked in a commit's tree (recursive, name-only). */
+    async listTrackedFiles(commitOrTree) {
+        const out = await this.git.raw(['ls-tree', '-r', '--name-only', commitOrTree]);
+        return out.split('\n').map((line) => line.trim()).filter(Boolean);
+    }
+    /** Reset the side index to exactly match a commit's tree (does not touch the working tree). */
+    async readTreeReset(commit) {
+        await this.git.raw(['read-tree', '--reset', commit]);
+    }
+    /** Write every file currently in the side index out to the working tree, overwriting existing files. */
+    async checkoutIndexAll() {
+        await this.git.raw(['checkout-index', '-a', '-f']);
+    }
+    /** `git diff` between two commit-ish values. Omit `to` to diff against the live working tree. */
+    async diff(from, to) {
+        return this.git.raw(to ? ['diff', from, to] : ['diff', from]);
+    }
+    /** `git diff --stat` between two commit-ish values. Omit `to` to diff against the live working tree. */
+    async diffStat(from, to) {
+        return this.git.raw(to ? ['diff', '--stat', from, to] : ['diff', '--stat', from]);
+    }
+    /** `git diff --name-only` between two commit-ish values. Omit `to` to diff against the live working tree. */
+    async diffNameOnly(from, to) {
+        const out = await this.git.raw(to ? ['diff', '--name-only', from, to] : ['diff', '--name-only', from]);
+        return out.split('\n').map((line) => line.trim()).filter(Boolean);
+    }
+    /** `git gc --prune=now` on the side repo. */
+    async gc() {
+        await this.git.raw(['gc', '--prune=now', '--quiet']);
+    }
+}

package/dist/platform/workspace/checkpoint/types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * types.ts
+ *
+ * Types for the workspace checkpoint engine (`WorkspaceCheckpointManager`).
+ *
+ * NAMING: this is deliberately "WorkspaceCheckpoint" / `wcp_` ids, NOT
+ * "checkpoint" bare. "checkpoint" is already used for two unrelated concepts
+ * in this codebase:
+ *   - compaction boundary commits (`cpt_` ids, ../../runtime/compaction/strategies/boundary-commit.ts)
+ *     — a CONVERSATION snapshot (messages/tokens), not a filesystem snapshot.
+ *   - the generic retention `CheckpointRecord` (../../runtime/retention/types.ts)
+ *     — a size/age/count bookkeeping record reused by both the boundary-commit
+ *     GC path and this module's GC path, but tracked in independent
+ *     `RetentionPolicy` instances so pruning one never touches the other.
+ *
+ * A WorkspaceCheckpoint is a whole-workspace filesystem snapshot stored as a
+ * commit object in a hidden side git repository (see side-git.ts) — never a
+ * conversation snapshot, never mixed with the user's real git history.
+ */
+import type { RetentionClass } from '../../runtime/retention/types.js';
+export type { RetentionClass };
+/**
+ * What triggered a checkpoint to be created.
+ *
+ * - `turn`      — automatic snapshot taken at a conversation turn boundary
+ *                 (TURN_COMPLETED / TURN_ERROR / TURN_CANCEL).
+ * - `agent-run` — automatic snapshot taken after a spawned agent's changes
+ *                 have been merged into the main workspace (AGENT_COMPLETED).
+ * - `manual`    — explicit user-requested checkpoint (e.g. TUI `/checkpoint`).
+ */
+export type CheckpointKind = 'turn' | 'agent-run' | 'manual';
+/**
+ * Metadata record for a single workspace checkpoint.
+ *
+ * Persisted in the manifest (`index.json`, via JsonFileStore) alongside the
+ * side git repo that actually holds the commit/blob/tree objects. The
+ * manifest exists because git commit messages are a lossy encoding for
+ * structured metadata and because `list()` / retention need it without
+ * reading git object contents.
+ */
+export interface WorkspaceCheckpoint {
+    /** Unique id, format `wcp_<ts36>_<rand8>`. Also the ref name suffix under refs/goodvibes/checkpoints/<id>. */
+    readonly id: string;
+    /** What triggered this checkpoint. */
+    readonly kind: CheckpointKind;
+    /** Human-readable label. Auto-generated for turn/agent-run kinds, user-supplied for manual. */
+    readonly label: string;
+    /** Unix timestamp (ms) when the checkpoint was created. */
+    readonly createdAt: number;
+    /** id of the checkpoint this one was created on top of, or null for the first checkpoint ever taken. */
+    readonly parentId: string | null;
+    /** Turn id, when kind === 'turn' (or when passed explicitly). */
+    readonly turnId?: string | undefined;
+    /** Agent id, when kind === 'agent-run' (or when passed explicitly). */
+    readonly agentId?: string | undefined;
+    /** Retention class controlling how long this checkpoint survives gc(). */
+    readonly retentionClass: RetentionClass;
+    /** Git commit hash (in the side repo's object store) this checkpoint points to. */
+    readonly commit: string;
+    /**
+     * Approximate bytes of NEW content this checkpoint introduced relative to
+     * its parent (unchanged files are deduped by git and cost ~0; this is not
+     * exact object-store accounting, it is the sum of on-disk sizes of the
+     * files that differ from the parent, read at commit time).
+     */
+    readonly sizeBytes: number;
+}
+/** Result of `WorkspaceCheckpointManager.diff()`. */
+export interface CheckpointDiff {
+    /** The checkpoint id (or ref) diffed from. */
+    readonly from: string;
+    /** The checkpoint id diffed to, or the literal string 'WORKING' when diffed against the live working tree. */
+    readonly to: string;
+    /** Paths that differ between `from` and `to`. */
+    readonly files: string[];
+    /** Unified diff text (`git diff`). */
+    readonly unifiedDiff: string;
+    /** `git diff --stat` text. */
+    readonly stat: string;
+}
+/** Result of `WorkspaceCheckpointManager.restore()`. */
+export interface RestoreResult {
+    /** The checkpoint id that was restored. */
+    readonly checkpointId: string;
+    /**
+     * id of the safety checkpoint taken immediately before restoring, or null
+     * when `safetyCheckpoint: false` was passed, or when the working tree was
+     * already identical to the checkpoint being restored (no-op dedupe).
+     */
+    readonly safetyCheckpointId: string | null;
+    /** Paths written or overwritten to match the restored checkpoint. */
+    readonly restoredFiles: string[];
+    /** Paths that existed (and were tracked by this engine) after the checkpoint but not in it, and were removed. */
+    readonly removedFiles: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/platform/workspace/checkpoint/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/platform/workspace/checkpoint/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEvE,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAC;AAE7D;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,8GAA8G;IAC9G,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,+FAA+F;IAC/F,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wGAAwG;IACxG,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,iEAAiE;IACjE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,uEAAuE;IACvE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,0EAA0E;IAC1E,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,qDAAqD;AACrD,MAAM,WAAW,cAAc;IAC7B,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8GAA8G;IAC9G,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IACzB,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,8BAA8B;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,wDAAwD;AACxD,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,qEAAqE;IACrE,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC;IACjC,iHAAiH;IACjH,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC;CACjC"}

package/dist/platform/workspace/checkpoint/types.js

@@ -0,0 +1,20 @@
+/**
+ * types.ts
+ *
+ * Types for the workspace checkpoint engine (`WorkspaceCheckpointManager`).
+ *
+ * NAMING: this is deliberately "WorkspaceCheckpoint" / `wcp_` ids, NOT
+ * "checkpoint" bare. "checkpoint" is already used for two unrelated concepts
+ * in this codebase:
+ *   - compaction boundary commits (`cpt_` ids, ../../runtime/compaction/strategies/boundary-commit.ts)
+ *     — a CONVERSATION snapshot (messages/tokens), not a filesystem snapshot.
+ *   - the generic retention `CheckpointRecord` (../../runtime/retention/types.ts)
+ *     — a size/age/count bookkeeping record reused by both the boundary-commit
+ *     GC path and this module's GC path, but tracked in independent
+ *     `RetentionPolicy` instances so pruning one never touches the other.
+ *
+ * A WorkspaceCheckpoint is a whole-workspace filesystem snapshot stored as a
+ * commit object in a hidden side git repository (see side-git.ts) — never a
+ * conversation snapshot, never mixed with the user's real git history.
+ */
+export {};

package/dist/platform/workspace/index.d.ts

@@ -1,3 +1,4 @@
 export * from './daemon-home.js';
 export * from './workspace-swap-manager.js';
+export { WorkspaceCheckpointManager, type CreateCheckpointOptions, type RestoreOptions, type ListCheckpointsFilter, type WorkspaceCheckpointManagerOptions, type WorkspaceCheckpoint, type CheckpointKind, type CheckpointDiff, type RestoreResult, } from './checkpoint/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/platform/workspace/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platform/workspace/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platform/workspace/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,OAAO,EACL,0BAA0B,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,iCAAiC,EACtC,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,uBAAuB,CAAC"}

package/dist/platform/workspace/index.js

@@ -1,2 +1,3 @@
 export * from './daemon-home.js';
 export * from './workspace-swap-manager.js';
+export { WorkspaceCheckpointManager, } from './checkpoint/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-sdk",
-  "version": "0.36.0",
+  "version": "0.37.1",
   "description": "TypeScript SDK for building GoodVibes operator, peer, web, mobile, and daemon-connected apps with typed contracts, auth, realtime events, and transport layers.",
   "keywords": [
     "goodvibes",
@@ -453,14 +453,14 @@
   "sideEffects": false,
   "type": "module",
   "dependencies": {
-    "@pellux/goodvibes-contracts": "0.36.0",
-    "@pellux/goodvibes-daemon-sdk": "0.36.0",
-    "@pellux/goodvibes-errors": "0.36.0",
-    "@pellux/goodvibes-operator-sdk": "0.36.0",
-    "@pellux/goodvibes-peer-sdk": "0.36.0",
-    "@pellux/goodvibes-transport-core": "0.36.0",
-    "@pellux/goodvibes-transport-http": "0.36.0",
-    "@pellux/goodvibes-transport-realtime": "0.36.0"
+    "@pellux/goodvibes-contracts": "0.37.1",
+    "@pellux/goodvibes-daemon-sdk": "0.37.1",
+    "@pellux/goodvibes-errors": "0.37.1",
+    "@pellux/goodvibes-operator-sdk": "0.37.1",
+    "@pellux/goodvibes-peer-sdk": "0.37.1",
+    "@pellux/goodvibes-transport-core": "0.37.1",
+    "@pellux/goodvibes-transport-http": "0.37.1",
+    "@pellux/goodvibes-transport-realtime": "0.37.1"
   },
   "optionalDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",