hungry-ghost-hive 0.48.0 → 0.49.0

package/src/utils/paths.ts

@@ -1,6 +1,6 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { join, resolve } from 'path';
 
 export const HIVE_DIR_NAME = '.hive';
@@ -14,6 +14,7 @@ export interface HivePaths {
   hiveDir: string;
   dbPath: string;
   configPath: string;
+  workspaceIdPath: string;
   agentsDir: string;
   logsDir: string;
   reposDir: string;
@@ -42,6 +43,7 @@ export function getHivePaths(rootDir: string): HivePaths {
     hiveDir,
     dbPath: join(hiveDir, 'hive.db'),
     configPath: join(hiveDir, 'hive.config.yaml'),
+    workspaceIdPath: join(hiveDir, 'workspace.id'),
     agentsDir: join(hiveDir, AGENTS_DIR_NAME),
     logsDir: join(hiveDir, LOGS_DIR_NAME),
     reposDir: join(rootDir, REPOS_DIR_NAME),
@@ -52,3 +54,14 @@ export function getHivePaths(rootDir: string): HivePaths {
 export function isHiveWorkspace(dir: string): boolean {
   return existsSync(join(dir, HIVE_DIR_NAME));
 }
+
+/**
+ * Read the workspace ID from .hive/workspace.id.
+ * Returns null if the file does not exist (non-distributed mode).
+ */
+export function getWorkspaceId(paths: HivePaths): string | null {
+  if (!existsSync(paths.workspaceIdPath)) {
+    return null;
+  }
+  return readFileSync(paths.workspaceIdPath, 'utf-8').trim();
+}

package/src/utils/pr-sync.test.ts

@@ -1,7 +1,7 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import type { Database } from 'sql.js';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { SqliteProvider } from '../db/provider.js';
 import { createPullRequest } from '../db/queries/pull-requests.js';
 import { createTestDatabase } from '../db/queries/test-helpers.js';
 import { closeStaleGitHubPRs, getExistingPRIdentifiers, syncOpenGitHubPRs } from './pr-sync.js';
@@ -14,64 +14,65 @@ import { execa } from 'execa';
 
 const mockExeca = vi.mocked(execa);
 
-let db: Database;
+let db: SqliteProvider;
 
 beforeEach(async () => {
   vi.clearAllMocks();
-  db = await createTestDatabase();
+  const rawDb = await createTestDatabase();
+  db = new SqliteProvider(rawDb);
   // Create a 'manager' agent for logging (required by foreign key constraint)
-  db.run("INSERT INTO agents (id, type, status) VALUES ('manager', 'tech_lead', 'idle')");
+  db.db.run("INSERT INTO agents (id, type, status) VALUES ('manager', 'tech_lead', 'idle')");
 });
 
 describe('getExistingPRIdentifiers', () => {
-  it('should return empty sets when no PRs exist', () => {
-    const { existingBranches, existingPrNumbers } = getExistingPRIdentifiers(db);
+  it('should return empty sets when no PRs exist', async () => {
+    const { existingBranches, existingPrNumbers } = await getExistingPRIdentifiers(db);
 
     expect(existingBranches.size).toBe(0);
     expect(existingPrNumbers.size).toBe(0);
   });
 
-  it('should include all branch names when includeTerminalBranches is true', () => {
-    createPullRequest(db, { branchName: 'feature/open', githubPrNumber: 1 });
-    const mergedPR = createPullRequest(db, {
+  it('should include all branch names when includeTerminalBranches is true', async () => {
+    await createPullRequest(db, { branchName: 'feature/open', githubPrNumber: 1 });
+    const mergedPR = await createPullRequest(db, {
       branchName: 'feature/merged',
       githubPrNumber: 2,
     });
     // Manually set status to merged
-    db.run("UPDATE pull_requests SET status = 'merged' WHERE id = ?", [mergedPR.id]);
+    db.db.run("UPDATE pull_requests SET status = 'merged' WHERE id = ?", [mergedPR.id]);
 
-    const { existingBranches } = getExistingPRIdentifiers(db, true);
+    const { existingBranches } = await getExistingPRIdentifiers(db, true);
 
     expect(existingBranches.has('feature/open')).toBe(true);
     expect(existingBranches.has('feature/merged')).toBe(true);
   });
 
-  it('should exclude terminal branch names when includeTerminalBranches is false', () => {
-    createPullRequest(db, { branchName: 'feature/open', githubPrNumber: 1 });
-    const mergedPR = createPullRequest(db, {
+  it('should exclude terminal branch names when includeTerminalBranches is false', async () => {
+    await createPullRequest(db, { branchName: 'feature/open', githubPrNumber: 1 });
+    const mergedPR = await createPullRequest(db, {
       branchName: 'feature/merged',
       githubPrNumber: 2,
     });
-    const closedPR = createPullRequest(db, {
+    const closedPR = await createPullRequest(db, {
       branchName: 'feature/closed',
       githubPrNumber: 3,
     });
-    db.run("UPDATE pull_requests SET status = 'merged' WHERE id = ?", [mergedPR.id]);
-    db.run("UPDATE pull_requests SET status = 'closed' WHERE id = ?", [closedPR.id]);
+    db.db.run("UPDATE pull_requests SET status = 'merged' WHERE id = ?", [mergedPR.id]);
+    db.db.run("UPDATE pull_requests SET status = 'closed' WHERE id = ?", [closedPR.id]);
 
-    const { existingBranches } = getExistingPRIdentifiers(db, false);
+    const { existingBranches } = await getExistingPRIdentifiers(db, false);
 
     expect(existingBranches.has('feature/open')).toBe(true);
     expect(existingBranches.has('feature/merged')).toBe(false);
     expect(existingBranches.has('feature/closed')).toBe(false);
   });
 
-  it('should collect PR numbers and filter out nulls', () => {
-    createPullRequest(db, { branchName: 'feature/a', githubPrNumber: 42 });
-    createPullRequest(db, { branchName: 'feature/b', githubPrNumber: null });
-    createPullRequest(db, { branchName: 'feature/c', githubPrNumber: 99 });
+  it('should collect PR numbers and filter out nulls', async () => {
+    await createPullRequest(db, { branchName: 'feature/a', githubPrNumber: 42 });
+    await createPullRequest(db, { branchName: 'feature/b', githubPrNumber: null });
+    await createPullRequest(db, { branchName: 'feature/c', githubPrNumber: 99 });
 
-    const { existingPrNumbers } = getExistingPRIdentifiers(db);
+    const { existingPrNumbers } = await getExistingPRIdentifiers(db);
 
     expect(existingPrNumbers.has(42)).toBe(true);
     expect(existingPrNumbers.has(99)).toBe(true);
@@ -200,7 +201,7 @@ describe('syncOpenGitHubPRs', () => {
     expect(existingBranches.has('feature/shared')).toBe(true);
     expect(existingPrNumbers.has(10)).toBe(true);
 
-    const countResult = db.exec('SELECT COUNT(*) as count FROM pull_requests');
+    const countResult = db.db.exec('SELECT COUNT(*) as count FROM pull_requests');
     expect(countResult[0].values[0][0]).toBe(1);
   });
 
@@ -238,7 +239,7 @@ describe('syncOpenGitHubPRs', () => {
     } as any);
 
     // Create a team so foreign key is satisfied
-    db.run(
+    db.db.run(
       "INSERT INTO teams (id, repo_url, repo_path, name) VALUES ('team-1', 'https://test', 'repo', 'Test')"
     );
 
@@ -246,13 +247,13 @@ describe('syncOpenGitHubPRs', () => {
 
     expect(result.synced).toBe(1);
     // Verify the PR was created with the team ID
-    const prs = db.exec('SELECT team_id FROM pull_requests');
+    const prs = db.db.exec('SELECT team_id FROM pull_requests');
     expect(prs[0].values[0][0]).toBe('team-1');
   });
 
   it('should extract story IDs from branch names that match the story ID pattern', async () => {
     // Create a story so the FK constraint is satisfied
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-GOD-001', 'Test', 'Test', 'planned')"
     );
 
@@ -270,7 +271,7 @@ describe('syncOpenGitHubPRs', () => {
 
     await syncOpenGitHubPRs(db, '/repo', null, new Set(), new Set());
 
-    const prs = db.exec('SELECT story_id FROM pull_requests');
+    const prs = db.db.exec('SELECT story_id FROM pull_requests');
     expect(prs[0].values[0][0]).toBe('STORY-GOD-001');
   });
 
@@ -293,7 +294,7 @@ describe('syncOpenGitHubPRs', () => {
     expect(result.imported).toHaveLength(1);
 
     // Verify the PR was created with null story_id
-    const prs = db.exec('SELECT story_id FROM pull_requests');
+    const prs = db.db.exec('SELECT story_id FROM pull_requests');
     expect(prs[0].values[0][0]).toBeNull();
   });
 
@@ -318,7 +319,7 @@ describe('syncOpenGitHubPRs', () => {
 
   it('should skip PRs where story status is merged', async () => {
     // Create a merged story
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-MERGED-001', 'Merged Story', 'Test', 'merged')"
     );
 
@@ -342,7 +343,7 @@ describe('syncOpenGitHubPRs', () => {
 
   it('should import PRs with active (non-merged) stories', async () => {
     // Create an active story
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-ACTIVE-001', 'Active Story', 'Test', 'in_progress')"
     );
 
@@ -367,10 +368,10 @@ describe('syncOpenGitHubPRs', () => {
 
   it('should filter mixed PRs - import active stories and PRs without story IDs', async () => {
     // Create stories with different statuses
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-ACTIVE-001', 'Active', 'Test', 'planned')"
     );
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-MERGED-001', 'Merged', 'Test', 'merged')"
     );
 
@@ -491,7 +492,7 @@ describe('syncOpenGitHubPRs', () => {
     await syncOpenGitHubPRs(db, '/repo', null, new Set(), new Set(), null, maxAgeHours);
 
     // Check that a log entry was created
-    const logs = db.exec("SELECT * FROM agent_logs WHERE event_type = 'PR_SYNC_SKIPPED'");
+    const logs = db.db.exec("SELECT * FROM agent_logs WHERE event_type = 'PR_SYNC_SKIPPED'");
     expect(logs.length).toBeGreaterThan(0);
     expect(logs[0].values.length).toBeGreaterThan(0);
   });
@@ -512,7 +513,7 @@ describe('syncOpenGitHubPRs', () => {
     await syncOpenGitHubPRs(db, '/repo', null, new Set(), new Set());
 
     // Check that a log entry was created
-    const logs = db.exec("SELECT * FROM agent_logs WHERE event_type = 'PR_SYNC_SKIPPED'");
+    const logs = db.db.exec("SELECT * FROM agent_logs WHERE event_type = 'PR_SYNC_SKIPPED'");
     expect(logs.length).toBeGreaterThan(0);
     expect(logs[0].values.length).toBeGreaterThan(0);
   });
@@ -521,14 +522,14 @@ describe('syncOpenGitHubPRs', () => {
 describe('closeStaleGitHubPRs', () => {
   beforeEach(() => {
     // Insert a team so the function can iterate teams
-    db.run(
+    db.db.run(
       "INSERT INTO teams (id, repo_url, repo_path, name) VALUES ('team-1', 'https://github.com/test/repo', 'repos/test', 'Test')"
     );
   });
 
   it('should return empty array when no teams exist', async () => {
     // Remove the team inserted in beforeEach
-    db.run("DELETE FROM teams WHERE id = 'team-1'");
+    db.db.run("DELETE FROM teams WHERE id = 'team-1'");
 
     const result = await closeStaleGitHubPRs('/root', db);
 
@@ -564,10 +565,10 @@ describe('closeStaleGitHubPRs', () => {
   });
 
   it('should skip a GitHub PR that is already in the queue', async () => {
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-TST-001', 'Test', 'Test', 'in_progress')"
     );
-    const pr = createPullRequest(db, {
+    const pr = await createPullRequest(db, {
       storyId: 'STORY-TST-001',
       branchName: 'feature/STORY-TST-001-work',
       githubPrNumber: 10,
@@ -598,11 +599,11 @@ describe('closeStaleGitHubPRs', () => {
   });
 
   it('should close a stale GitHub PR and return ClosedPRInfo', async () => {
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-TST-002', 'Test', 'Test', 'in_progress')"
     );
     // Queue PR has github_pr_number 20 (the newer one)
-    createPullRequest(db, {
+    await createPullRequest(db, {
       storyId: 'STORY-TST-002',
       branchName: 'feature/STORY-TST-002-v2',
       githubPrNumber: 20,
@@ -634,10 +635,10 @@ describe('closeStaleGitHubPRs', () => {
   });
 
   it('should include superseding PR number in the log message', async () => {
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-TST-003', 'Test', 'Test', 'in_progress')"
     );
-    createPullRequest(db, {
+    await createPullRequest(db, {
       storyId: 'STORY-TST-003',
       branchName: 'feature/STORY-TST-003-v2',
       githubPrNumber: 30,
@@ -660,7 +661,9 @@ describe('closeStaleGitHubPRs', () => {
 
     await closeStaleGitHubPRs('/root', db);
 
-    const logs = db.exec("SELECT message, metadata FROM agent_logs WHERE event_type = 'PR_CLOSED'");
+    const logs = db.db.exec(
+      "SELECT message, metadata FROM agent_logs WHERE event_type = 'PR_CLOSED'"
+    );
     expect(logs.length).toBeGreaterThan(0);
     const message = logs[0].values[0][0] as string;
     expect(message).toContain('#15');
@@ -671,10 +674,10 @@ describe('closeStaleGitHubPRs', () => {
   });
 
   it('should not close if gh CLI throws and should not include in result', async () => {
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-TST-004', 'Test', 'Test', 'in_progress')"
     );
-    createPullRequest(db, {
+    await createPullRequest(db, {
       storyId: 'STORY-TST-004',
       branchName: 'feature/STORY-TST-004-v2',
       githubPrNumber: 40,
@@ -702,10 +705,10 @@ describe('closeStaleGitHubPRs', () => {
   });
 
   it('should skip PRs not targeting the configured base branch', async () => {
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-TST-005', 'Test', 'Test', 'in_progress')"
     );
-    createPullRequest(db, {
+    await createPullRequest(db, {
       storyId: 'STORY-TST-005',
       branchName: 'feature/STORY-TST-005-v2',
       githubPrNumber: 50,
@@ -736,10 +739,10 @@ describe('closeStaleGitHubPRs', () => {
   });
 
   it('should only close PRs targeting the configured base branch when it is non-main', async () => {
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-TST-006', 'Test', 'Test', 'in_progress')"
     );
-    createPullRequest(db, {
+    await createPullRequest(db, {
       storyId: 'STORY-TST-006',
       branchName: 'feature/STORY-TST-006-v2',
       githubPrNumber: 60,
@@ -768,10 +771,10 @@ describe('closeStaleGitHubPRs', () => {
   });
 
   it('should not close PRs targeting main when configured base branch is feat/memento-refactor', async () => {
-    db.run(
+    db.db.run(
       "INSERT INTO stories (id, title, description, status) VALUES ('STORY-TST-007', 'Test', 'Test', 'in_progress')"
     );
-    createPullRequest(db, {
+    await createPullRequest(db, {
       storyId: 'STORY-TST-007',
       branchName: 'feature/STORY-TST-007-v2',
       githubPrNumber: 70,

package/src/utils/pr-sync.ts

@@ -1,9 +1,8 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import { execa } from 'execa';
-import type { Database } from 'sql.js';
 import { syncStatusForStory } from '../connectors/project-management/operations.js';
-import { queryAll, withTransaction } from '../db/client.js';
+import type { DatabaseProvider } from '../db/provider.js';
 import { createLog } from '../db/queries/logs.js';
 import { createPullRequest } from '../db/queries/pull-requests.js';
 import { updateStory } from '../db/queries/stories.js';
@@ -53,23 +52,22 @@ interface ExistingPRNumberRow {
 /**
  * Build sets of existing branch names and PR numbers from the database.
  *
- * @param db - sql.js Database instance
+ * @param db - DatabaseProvider instance
  * @param includeTerminalBranches - If true, include merged/closed PR branches
  *   in the returned set (prevents re-importing previously synced PRs).
  *   Defaults to true.
  */
-export function getExistingPRIdentifiers(
-  db: Database,
+export async function getExistingPRIdentifiers(
+  db: DatabaseProvider,
   includeTerminalBranches = true
-): { existingBranches: Set<string>; existingPrNumbers: Set<number> } {
+): Promise<{ existingBranches: Set<string>; existingPrNumbers: Set<number> }> {
   const branchQuery = includeTerminalBranches
     ? 'SELECT branch_name FROM pull_requests'
     : "SELECT branch_name FROM pull_requests WHERE status NOT IN ('merged', 'closed')";
-  const branchRows = queryAll<ExistingPRBranchRow>(db, branchQuery);
+  const branchRows = await db.queryAll<ExistingPRBranchRow>(branchQuery);
   const existingBranches = new Set(branchRows.map(row => row.branch_name));
 
-  const numberRows = queryAll<ExistingPRNumberRow>(
-    db,
+  const numberRows = await db.queryAll<ExistingPRNumberRow>(
     `
     SELECT DISTINCT github_pr_number
     FROM pull_requests
@@ -111,7 +109,7 @@ export async function fetchOpenGitHubPRs(
  * - PRs with story IDs are only imported if the story exists and is not merged
  * - PRs older than maxAgeHours are skipped (age-based filtering)
  *
- * @param db        - sql.js Database instance
+ * @param db        - DatabaseProvider instance
  * @param repoDir   - Absolute path to the git repository
  * @param teamId    - Team ID to associate with created PRs (null for CLI usage)
  * @param existingBranches  - Set of branch names already in the queue
@@ -120,7 +118,7 @@ export async function fetchOpenGitHubPRs(
  * @param maxAgeHours - Optional max age in hours for PRs (default: no limit)
  */
 export async function syncOpenGitHubPRs(
-  db: Database,
+  db: DatabaseProvider,
   repoDir: string,
   teamId: string | null,
   existingBranches: Set<string>,
@@ -142,7 +140,7 @@ export async function syncOpenGitHubPRs(
       const ageHours = (Date.now() - prCreatedAt.getTime()) / (1000 * 60 * 60);
 
       if (ageHours > maxAgeHours) {
-        createLog(db, {
+        await createLog(db, {
           agentId: 'manager',
           eventType: 'PR_SYNC_SKIPPED',
           status: 'info',
@@ -164,15 +162,14 @@ export async function syncOpenGitHubPRs(
     // If the PR has a story ID, check if the story is active
     if (storyId) {
       // Check if the story exists and is active (not merged)
-      const storyRows = queryAll<{ id: string; status: string }>(
-        db,
+      const storyRows = await db.queryAll<{ id: string; status: string }>(
         `SELECT id, status FROM stories WHERE id = ? COLLATE NOCASE AND status != 'merged'`,
         [storyId]
       );
 
       // Skip PRs where story doesn't exist or is merged
       if (storyRows.length === 0) {
-        createLog(db, {
+        await createLog(db, {
           agentId: 'manager',
           eventType: 'PR_SYNC_SKIPPED',
           status: 'info',
@@ -188,7 +185,7 @@ export async function syncOpenGitHubPRs(
       }
     }
 
-    const pr = createPullRequest(db, {
+    const pr = await createPullRequest(db, {
       storyId,
       teamId,
       branchName: ghPR.headRefName,
@@ -222,14 +219,14 @@ export async function syncOpenGitHubPRs(
  */
 export async function syncAllTeamOpenPRs(
   root: string,
-  db: Database,
+  db: DatabaseProvider,
   saveFn: () => void,
   maxAgeHours?: number
 ): Promise<number> {
-  const teams = getAllTeams(db);
+  const teams = await getAllTeams(db);
   if (teams.length === 0) return 0;
 
-  const { existingBranches, existingPrNumbers } = getExistingPRIdentifiers(db, true);
+  const { existingBranches, existingPrNumbers } = await getExistingPRIdentifiers(db, true);
   let totalSynced = 0;
 
   for (const team of teams) {
@@ -265,10 +262,10 @@ export async function syncAllTeamOpenPRs(
  */
 export async function syncMergedPRsFromGitHub(
   root: string,
-  db: Database,
+  db: DatabaseProvider,
   saveFn: () => void
 ): Promise<number> {
-  const teams = getAllTeams(db);
+  const teams = await getAllTeams(db);
   if (teams.length === 0) return 0;
 
   let storiesUpdated = 0;
@@ -308,8 +305,7 @@ export async function syncMergedPRsFromGitHub(
       }
 
       const placeholders = candidateStoryIds.map(() => '?').join(',');
-      const updatableStories = queryAll<{ id: string }>(
-        db,
+      const updatableStories = await db.queryAll<{ id: string }>(
         `
         SELECT id
         FROM stories
@@ -333,10 +329,10 @@ export async function syncMergedPRsFromGitHub(
         continue;
       }
 
-      await withTransaction(db, () => {
+      await db.withTransaction(async () => {
         for (const update of toUpdate) {
-          updateStory(db, update.storyId, { status: 'merged', assignedAgentId: null });
-          createLog(db, {
+          await updateStory(db, update.storyId, { status: 'merged', assignedAgentId: null });
+          await createLog(db, {
             agentId: 'manager',
             storyId: update.storyId,
             eventType: 'STORY_MERGED',
@@ -378,15 +374,15 @@ export interface ClosedPRInfo {
  * in the hive merge queue (i.e., the GitHub PR is stale/orphaned).
  *
  * @param root  - Root directory
- * @param db    - sql.js Database instance
+ * @param db    - DatabaseProvider instance
  * @returns Array of ClosedPRInfo for each PR that was closed.
  */
 export async function closeStaleGitHubPRs(
   root: string,
-  db: Database,
+  db: DatabaseProvider,
   baseBranch = 'main'
 ): Promise<ClosedPRInfo[]> {
-  const teams = getAllTeams(db);
+  const teams = await getAllTeams(db);
   if (teams.length === 0) return [];
 
   const closed: ClosedPRInfo[] = [];
@@ -408,8 +404,7 @@ export async function closeStaleGitHubPRs(
         if (!storyId) continue;
 
         // Check if there are other PRs for this story in the queue
-        const prsForStory = queryAll<{ id: string; github_pr_number: number | null }>(
-          db,
+        const prsForStory = await db.queryAll<{ id: string; github_pr_number: number | null }>(
           `
           SELECT id, github_pr_number
           FROM pull_requests
@@ -444,7 +439,7 @@ export async function closeStaleGitHubPRs(
                 cwd: repoDir,
                 timeout: GH_CLI_TIMEOUT_MS,
               });
-              createLog(db, {
+              await createLog(db, {
                 agentId: 'manager',
                 storyId,
                 eventType: 'PR_CLOSED',

package/src/utils/with-hive-context.ts

@@ -2,6 +2,7 @@
 
 import chalk from 'chalk';
 import { join } from 'path';
+import { loadConfig } from '../config/loader.js';
 import {
   getDatabase,
   getReadOnlyDatabase,
@@ -9,7 +10,8 @@ import {
   type ReadOnlyDatabaseClient,
 } from '../db/client.js';
 import { acquireLock } from '../db/lock.js';
-import { findHiveRoot, getHivePaths, type HivePaths } from './paths.js';
+import { createPostgresProvider } from '../db/postgres-provider.js';
+import { findHiveRoot, getHivePaths, getWorkspaceId, type HivePaths } from './paths.js';
 
 export interface HiveContext {
   root: string;
@@ -38,8 +40,25 @@ function resolveRoot(): { root: string; paths: HivePaths } {
   return { root, paths };
 }
 
+/**
+ * Check if this workspace is running in distributed (Postgres) mode.
+ */
+function isDistributedMode(paths: HivePaths): boolean {
+  try {
+    const config = loadConfig(paths.hiveDir);
+    return config.distributed === true;
+  } catch {
+    return false;
+  }
+}
+
 export async function withHiveContext<T>(fn: (ctx: HiveContext) => Promise<T> | T): Promise<T> {
   const { root, paths } = resolveRoot();
+
+  if (isDistributedMode(paths)) {
+    return withDistributedHiveContext(root, paths, fn);
+  }
+
   const dbLockPath = join(paths.hiveDir, 'db');
 
   // Acquire database lock to prevent concurrent access and race conditions
@@ -93,11 +112,51 @@ export async function withHiveContext<T>(fn: (ctx: HiveContext) => Promise<T> |
   }
 }
 
+async function withDistributedHiveContext<T>(
+  root: string,
+  paths: HivePaths,
+  fn: (ctx: HiveContext) => Promise<T> | T
+): Promise<T> {
+  const workspaceId = getWorkspaceId(paths);
+  if (!workspaceId) {
+    throw new Error(
+      'Distributed mode is enabled but workspace.id file is missing. ' +
+        'Re-run "hive init --distributed" to fix.'
+    );
+  }
+
+  const provider = await createPostgresProvider(workspaceId);
+  // Create a DatabaseClient-compatible wrapper around the Postgres provider
+  const db: DatabaseClient = {
+    db: null as never, // No sql.js database in distributed mode
+    provider,
+    close: () => {
+      provider.close();
+    },
+    save: () => {
+      provider.save();
+    },
+    runMigrations: () => {
+      provider.runMigrations();
+    },
+  };
+
+  try {
+    return await fn({ root, paths, db });
+  } finally {
+    await provider.close();
+  }
+}
+
 export async function withReadOnlyHiveContext<T>(
   fn: (ctx: ReadOnlyHiveContext) => Promise<T> | T
 ): Promise<T> {
   const { root, paths } = resolveRoot();
 
+  if (isDistributedMode(paths)) {
+    return withDistributedReadOnlyHiveContext(root, paths, fn);
+  }
+
   const db = await getReadOnlyDatabase(paths.hiveDir);
   try {
     return await fn({ root, paths, db });
@@ -106,6 +165,35 @@ export async function withReadOnlyHiveContext<T>(
   }
 }
 
+async function withDistributedReadOnlyHiveContext<T>(
+  root: string,
+  paths: HivePaths,
+  fn: (ctx: ReadOnlyHiveContext) => Promise<T> | T
+): Promise<T> {
+  const workspaceId = getWorkspaceId(paths);
+  if (!workspaceId) {
+    throw new Error(
+      'Distributed mode is enabled but workspace.id file is missing. ' +
+        'Re-run "hive init --distributed" to fix.'
+    );
+  }
+
+  const provider = await createPostgresProvider(workspaceId);
+  const db: ReadOnlyDatabaseClient = {
+    db: null as never, // No sql.js database in distributed mode
+    provider,
+    close: () => {
+      provider.close();
+    },
+  };
+
+  try {
+    return await fn({ root, paths, db });
+  } finally {
+    await provider.close();
+  }
+}
+
 export function withHiveRoot<T>(fn: (ctx: HiveRootContext) => T): T {
   const { root, paths } = resolveRoot();
   return fn({ root, paths });