hungry-ghost-hive 0.49.0 → 0.50.0

package/src/cli/dashboard/index.ts

@@ -3,10 +3,12 @@
 import blessed from 'blessed';
 import { appendFileSync, existsSync, renameSync, statSync } from 'fs';
 import { join } from 'path';
+import { loadConfig } from '../../config/loader.js';
 import { getReadOnlyDatabase, type ReadOnlyDatabaseClient } from '../../db/client.js';
+import { createPostgresProvider } from '../../db/postgres-provider.js';
 import type { DatabaseProvider } from '../../db/provider.js';
 import { getAllRequirements } from '../../db/queries/requirements.js';
-import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+import { findHiveRoot, getHivePaths, getWorkspaceId } from '../../utils/paths.js';
 import { getVersion } from '../../utils/version.js';
 import { createActivityPanel, updateActivityPanel } from './panels/activity.js';
 import { createAgentsPanel, updateAgentsPanel } from './panels/agents.js';
@@ -56,11 +58,39 @@ export async function startDashboard(options: DashboardOptions = {}): Promise<vo
 
   const paths = getHivePaths(root);
   const dbPath = join(paths.hiveDir, 'hive.db');
-  const isDistributed = !existsSync(dbPath);
+  let isDistributed = false;
+  try {
+    const config = loadConfig(paths.hiveDir);
+    isDistributed = config.distributed === true;
+  } catch {
+    // fallback: not distributed
+  }
   debugLog(
     `Dashboard starting - root: ${root}, hiveDir: ${paths.hiveDir}, distributed: ${isDistributed}`
   );
-  let db: ReadOnlyDatabaseClient = await getReadOnlyDatabase(paths.hiveDir);
+
+  async function createDbClient(): Promise<ReadOnlyDatabaseClient> {
+    if (isDistributed) {
+      const workspaceId = getWorkspaceId(paths);
+      if (!workspaceId) {
+        throw new Error(
+          'Distributed mode but workspace.id is missing. Re-run "hive init --distributed".'
+        );
+      }
+      const envPath = join(root!, '.env');
+      const provider = await createPostgresProvider(workspaceId, envPath);
+      return {
+        db: null as never,
+        provider,
+        close: () => {
+          provider.close();
+        },
+      };
+    }
+    return getReadOnlyDatabase(paths.hiveDir);
+  }
+
+  let db: ReadOnlyDatabaseClient = await createDbClient();
   let lastDbMtime = isDistributed ? 0 : statSync(dbPath).mtimeMs;
   const refreshInterval = options.refreshInterval || 5000;
   const version = getVersion();
@@ -99,7 +129,7 @@ export async function startDashboard(options: DashboardOptions = {}): Promise<vo
 
   // Create panels
   const agentsPanel = createAgentsPanel(screen, db.provider, pauseRefresh, resumeRefresh);
-  const storiesPanel = createStoriesPanel(screen, db.db);
+  const storiesPanel = createStoriesPanel(screen, db.provider);
   const pipelinePanel = createPipelinePanel(screen, db.provider);
   const activityPanel = createActivityPanel(screen, db.provider);
   const mergeQueuePanel = createMergeQueuePanel(screen, db.provider);
@@ -144,9 +174,9 @@ export async function startDashboard(options: DashboardOptions = {}): Promise<vo
 
       if (shouldReload) {
         debugLog(`Database changed - reloading from ${paths.hiveDir}`);
-        const newDb = await getReadOnlyDatabase(paths.hiveDir);
+        const newDb = await createDbClient();
         try {
-          db.db.close();
+          db.close();
         } catch (_error) {
           /* ignore close errors */
         }
@@ -161,7 +191,7 @@ export async function startDashboard(options: DashboardOptions = {}): Promise<vo
       );
 
       await updateAgentsPanel(agentsPanel, db.provider);
-      await updateStoriesPanel(storiesPanel, db.db);
+      await updateStoriesPanel(storiesPanel, db.provider);
       await updatePipelinePanel(pipelinePanel, db.provider);
       await updateActivityPanel(activityPanel, db.provider);
       await updateMergeQueuePanel(mergeQueuePanel, db.provider);
@@ -191,7 +221,7 @@ export async function startDashboard(options: DashboardOptions = {}): Promise<vo
   screen.key(['q', 'C-c'], () => {
     if (currentTimeout) clearTimeout(currentTimeout);
     try {
-      db.db.close();
+      db.close();
     } catch (_error) {
       /* ignore */
     }

package/src/cli/dashboard/panels/activity.ts

@@ -60,8 +60,11 @@ export async function updateActivityPanel(
   box.setScrollPerc(100);
 }
 
-function formatTimestamp(timestamp: string): string {
-  return timestamp.substring(11, 19);
+function formatTimestamp(timestamp: string | Date): string {
+  if (timestamp instanceof Date) {
+    return timestamp.toISOString().substring(11, 19);
+  }
+  return String(timestamp).substring(11, 19);
 }
 
 function formatEventType(event: string): string {

package/src/cli/dashboard/panels/stories.ts

@@ -1,10 +1,13 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import blessed, { type Widgets } from 'blessed';
-import type { Database } from 'sql.js';
-import { queryAll, type StoryRow } from '../../../db/client.js';
+import type { StoryRow } from '../../../db/client.js';
+import type { DatabaseProvider } from '../../../db/provider.js';
 
-export function createStoriesPanel(screen: Widgets.Screen, db: Database): Widgets.ListTableElement {
+export function createStoriesPanel(
+  screen: Widgets.Screen,
+  db: DatabaseProvider
+): Widgets.ListTableElement {
   const table = blessed.listtable({
     parent: screen,
     top: '30%',
@@ -32,10 +35,9 @@ export function createStoriesPanel(screen: Widgets.Screen, db: Database): Widget
 
 export async function updateStoriesPanel(
   table: Widgets.ListTableElement,
-  db: Database
+  db: DatabaseProvider
 ): Promise<void> {
-  const stories = queryAll<StoryRow>(
-    db,
+  const stories = await db.queryAll<StoryRow>(
     `
     SELECT * FROM stories
     ORDER BY

package/src/db/postgres-provider.ts

@@ -83,6 +83,66 @@ function detectTable(sql: string): string | null {
   return null;
 }
 
+/**
+ * Detect the alias (or table name) for the primary table in a SQL statement.
+ * For `SELECT ... FROM stories s LEFT JOIN ...`, returns "s".
+ * For `SELECT ... FROM stories LEFT JOIN ...`, returns "stories".
+ * For UPDATE/DELETE, returns the table name or alias.
+ */
+function detectTableQualifier(sql: string): string | null {
+  const normalized = sql.replace(/\s+/g, ' ').trim();
+
+  // SELECT ... FROM table [alias] [JOIN|WHERE|ORDER|GROUP|HAVING|LIMIT|,|)]
+  const selectMatch = normalized.match(/FROM\s+(\w+)(?:\s+(?:AS\s+)?(\w+))?/i);
+  if (selectMatch) {
+    const alias = selectMatch[2];
+    const table = selectMatch[1];
+    // Only treat as alias if the next word is not a SQL keyword
+    if (alias) {
+      const upper = alias.toUpperCase();
+      const keywords = new Set([
+        'WHERE',
+        'LEFT',
+        'RIGHT',
+        'INNER',
+        'OUTER',
+        'CROSS',
+        'JOIN',
+        'ON',
+        'ORDER',
+        'GROUP',
+        'HAVING',
+        'LIMIT',
+        'OFFSET',
+        'UNION',
+        'EXCEPT',
+        'INTERSECT',
+        'FOR',
+        'SET',
+        'VALUES',
+      ]);
+      if (!keywords.has(upper)) {
+        return alias;
+      }
+    }
+    return table;
+  }
+
+  // UPDATE table [alias]
+  const updateMatch = normalized.match(/UPDATE\s+(\w+)(?:\s+(?:AS\s+)?(\w+))?/i);
+  if (updateMatch) {
+    return updateMatch[2] || updateMatch[1];
+  }
+
+  // DELETE FROM table [alias]
+  const deleteMatch = normalized.match(/DELETE\s+FROM\s+(\w+)(?:\s+(?:AS\s+)?(\w+))?/i);
+  if (deleteMatch) {
+    return deleteMatch[2] || deleteMatch[1];
+  }
+
+  return null;
+}
+
 /**
  * Check if a SQL statement needs workspace_id injection.
  */
@@ -123,6 +183,8 @@ function injectInsertWorkspaceId(
 /**
  * Inject workspace_id into SELECT/UPDATE/DELETE WHERE clauses.
  * Adds `AND workspace_id = ?` to existing WHERE, or `WHERE workspace_id = ?` if none.
+ * When the query uses JOINs, qualifies workspace_id with the primary table alias
+ * to avoid ambiguous column references.
  */
 function injectWhereWorkspaceId(
   sql: string,
@@ -136,18 +198,46 @@ function injectWhereWorkspaceId(
     return { sql, params };
   }
 
+  // Determine if we need to qualify workspace_id (JOIN queries have ambiguous columns)
+  const hasJoin = /\bJOIN\b/i.test(normalized);
+  const qualifier = hasJoin ? detectTableQualifier(sql) : null;
+  const wsCol = qualifier ? `${qualifier}.workspace_id` : 'workspace_id';
+
   const upperSql = normalized.toUpperCase();
 
   // Find WHERE clause position
   const whereIndex = upperSql.indexOf(' WHERE ');
 
   if (whereIndex !== -1) {
-    // Insert workspace_id condition right after WHERE
+    // Append workspace_id condition at the end of the WHERE clause.
+    // We must NOT prepend because params are positional — SET clause params
+    // come before WHERE clause params, and prepending would shift them.
     const before = normalized.substring(0, whereIndex + 7); // includes " WHERE "
     const after = normalized.substring(whereIndex + 7);
+
+    // Find any trailing clauses (ORDER BY, GROUP BY, etc.) after the WHERE
+    const upperAfter = after.toUpperCase();
+    const trailingPatterns = [
+      ' ORDER BY',
+      ' GROUP BY',
+      ' HAVING',
+      ' LIMIT',
+      ' OFFSET',
+      ' FOR UPDATE',
+    ];
+    let trailingPos = after.length;
+    for (const pattern of trailingPatterns) {
+      const idx = upperAfter.indexOf(pattern);
+      if (idx !== -1 && idx < trailingPos) {
+        trailingPos = idx;
+      }
+    }
+
+    const whereBody = after.substring(0, trailingPos);
+    const trailing = after.substring(trailingPos);
     return {
-      sql: `${before}workspace_id = ? AND ${after}`,
-      params: [workspaceId, ...params],
+      sql: `${before}${whereBody} AND ${wsCol} = ?${trailing}`,
+      params: [...params, workspaceId],
     };
   }
 
@@ -163,9 +253,16 @@ function injectWhereWorkspaceId(
 
   const before = normalized.substring(0, insertPos);
   const after = normalized.substring(insertPos);
+
+  // Count how many ? appear before the insertion point to determine where
+  // in the params array the workspace_id value should be spliced in.
+  const questionsBefore = (before.match(/\?/g) || []).length;
+  const newParams = [...params];
+  newParams.splice(questionsBefore, 0, workspaceId);
+
   return {
-    sql: `${before} WHERE workspace_id = ?${after}`,
-    params: [workspaceId, ...params],
+    sql: `${before} WHERE ${wsCol} = ?${after}`,
+    params: newParams,
   };
 }
 
@@ -191,6 +288,17 @@ function loadPgMigration(migrationName: string): string {
 
 const PG_MIGRATIONS = [{ name: '001-full-schema.sql' }];
 
+/**
+ * Strip SQLite-specific syntax that Postgres does not understand.
+ */
+function sanitizeForPostgres(sql: string): string {
+  // Remove COLLATE NOCASE (SQLite case-insensitive collation)
+  let result = sql.replace(/\s+COLLATE\s+NOCASE/gi, '');
+  // Convert INSERT OR IGNORE to INSERT ... ON CONFLICT DO NOTHING
+  result = result.replace(/INSERT\s+OR\s+IGNORE\s+INTO/gi, 'INSERT INTO');
+  return result;
+}
+
 /**
  * Postgres implementation of DatabaseProvider using node-postgres (pg).
  * All queries are automatically scoped by workspace_id for multi-tenant isolation.
@@ -242,12 +350,16 @@ export class PostgresProvider implements WritableDatabaseProvider {
   }
 
   async queryAll<T>(sql: string, params: unknown[] = []): Promise<T[]> {
-    let finalSql = sql;
+    let finalSql = sanitizeForPostgres(sql);
     let finalParams = params;
 
     if (needsWorkspaceScope(sql)) {
       const normalized = sql.replace(/\s+/g, ' ').trim().toUpperCase();
-      if (!normalized.startsWith('INSERT')) {
+      if (normalized.startsWith('INSERT')) {
+        const result = injectInsertWorkspaceId(finalSql, this.workspaceId, finalParams);
+        finalSql = result.sql;
+        finalParams = result.params;
+      } else {
         const result = injectWhereWorkspaceId(finalSql, this.workspaceId, finalParams);
         finalSql = result.sql;
         finalParams = result.params;
@@ -265,7 +377,7 @@ export class PostgresProvider implements WritableDatabaseProvider {
   }
 
   async run(sql: string, params: unknown[] = []): Promise<void> {
-    let finalSql = sql;
+    let finalSql = sanitizeForPostgres(sql);
     let finalParams = params;
 
     if (needsWorkspaceScope(sql)) {
@@ -340,11 +452,18 @@ export class PostgresProvider implements WritableDatabaseProvider {
  * Create a PostgresProvider from the HIVE_DATABASE_URL environment variable.
  * Loads .env file via dotenv if available.
  */
-export async function createPostgresProvider(workspaceId: string): Promise<PostgresProvider> {
-  // Load .env file if dotenv is available
+export async function createPostgresProvider(
+  workspaceId: string,
+  envPath?: string
+): Promise<PostgresProvider> {
+  // Load .env file if dotenv is available — use workspace root if provided
   try {
     const dotenv = await import('dotenv');
-    dotenv.config();
+    if (envPath) {
+      dotenv.config({ path: envPath });
+    } else {
+      dotenv.config();
+    }
   } catch {
     // dotenv not available, rely on environment variables
   }

package/src/db/queries/logs.ts

@@ -92,6 +92,17 @@ function inferAgentType(
 }
 
 async function getAgentColumnNames(provider: DatabaseProvider): Promise<Set<string>> {
+  try {
+    // Try Postgres information_schema first
+    const pgRows = await provider.queryAll<{ column_name: string }>(
+      "SELECT column_name FROM information_schema.columns WHERE table_name = 'agents'"
+    );
+    if (pgRows.length > 0) {
+      return new Set(pgRows.map(r => r.column_name));
+    }
+  } catch {
+    // Fall back to SQLite PRAGMA
+  }
   const rows = await provider.queryAll<{ name: string }>('PRAGMA table_info(agents)');
   const columnNames = new Set<string>();
   for (const row of rows) {
@@ -133,13 +144,18 @@ async function ensureLogAgentExists(provider: DatabaseProvider, agentId: string)
   }
 
   const placeholders = insertColumns.map(() => '?').join(', ');
-  await provider.run(
-    `
-    INSERT OR IGNORE INTO agents (${insertColumns.join(', ')})
-    VALUES (${placeholders})
-  `,
-    insertValues
-  );
+  try {
+    await provider.run(
+      `
+      INSERT INTO agents (${insertColumns.join(', ')})
+      VALUES (${placeholders})
+      ON CONFLICT DO NOTHING
+    `,
+      insertValues
+    );
+  } catch {
+    // Ignore insert conflicts — agent row already exists
+  }
 }
 
 async function resolveLogAgentId(provider: DatabaseProvider, rawAgentId: string): Promise<string> {
@@ -188,10 +204,13 @@ export async function createLog(
   const resolvedAgentId = await resolveLogAgentId(provider, input.agentId);
   const resolvedStoryId = await resolveLogStoryId(provider, input.storyId);
 
-  await provider.run(
+  // Use queryOne with RETURNING to get the inserted id in a single statement.
+  // RETURNING is supported by both SQLite (3.35+) and Postgres.
+  const result = await provider.queryOne<{ id: number }>(
     `
     INSERT INTO agent_logs (agent_id, story_id, event_type, status, message, metadata, timestamp)
     VALUES (?, ?, ?, ?, ?, ?, ?)
+    RETURNING id
   `,
     [
       resolvedAgentId,
@@ -204,8 +223,6 @@ export async function createLog(
     ]
   );
 
-  // Get the last inserted row
-  const result = await provider.queryOne<{ id: number }>('SELECT last_insert_rowid() as id');
   return (await getLogById(provider, result?.id || 0))!;
 }
 

package/src/db/queries/requirements.ts

@@ -77,7 +77,7 @@ export async function getRequirementById(
 
 export async function getAllRequirements(provider: DatabaseProvider): Promise<RequirementRow[]> {
   return await provider.queryAll<RequirementRow>(
-    'SELECT * FROM requirements ORDER BY created_at DESC, rowid DESC'
+    'SELECT * FROM requirements ORDER BY created_at DESC, id DESC'
   );
 }
 
@@ -86,7 +86,7 @@ export async function getRequirementsByStatus(
   status: RequirementStatus
 ): Promise<RequirementRow[]> {
   return await provider.queryAll<RequirementRow>(
-    'SELECT * FROM requirements WHERE status = ? ORDER BY created_at DESC, rowid DESC',
+    'SELECT * FROM requirements WHERE status = ? ORDER BY created_at DESC, id DESC',
     [status]
   );
 }
@@ -97,7 +97,7 @@ export async function getPendingRequirements(
   return await provider.queryAll<RequirementRow>(`
     SELECT * FROM requirements
     WHERE status IN ('pending', 'planning', 'in_progress')
-    ORDER BY created_at, rowid
+    ORDER BY created_at, id
   `);
 }
 

package/src/orchestrator/scheduler.ts

@@ -1143,7 +1143,7 @@ export class Scheduler {
    */
   private async isGodmodeActive(): Promise<boolean> {
     const activeRequirements = await this.provider.queryAll<RequirementRow>(
-      `SELECT * FROM requirements WHERE status IN ('planning', 'planned', 'in_progress') AND godmode = 1`
+      `SELECT * FROM requirements WHERE status IN ('planning', 'planned', 'in_progress') AND godmode = true`
     );
     return activeRequirements.length > 0;
   }

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

@@ -125,7 +125,9 @@ async function withDistributedHiveContext<T>(
     );
   }
 
-  const provider = await createPostgresProvider(workspaceId);
+  const { join } = await import('path');
+  const envPath = join(root, '.env');
+  const provider = await createPostgresProvider(workspaceId, envPath);
   // Create a DatabaseClient-compatible wrapper around the Postgres provider
   const db: DatabaseClient = {
     db: null as never, // No sql.js database in distributed mode
@@ -178,7 +180,9 @@ async function withDistributedReadOnlyHiveContext<T>(
     );
   }
 
-  const provider = await createPostgresProvider(workspaceId);
+  const { join } = await import('path');
+  const envPath = join(root, '.env');
+  const provider = await createPostgresProvider(workspaceId, envPath);
   const db: ReadOnlyDatabaseClient = {
     db: null as never, // No sql.js database in distributed mode
     provider,