@tt-a1i/hive 2.1.4 → 2.1.5

package/dist/src/server/team-memory-dream-run-store.js

@@ -42,6 +42,19 @@ export const createDreamRunStore = (db) => {
            WHERE workspace_id = ?
              AND status = 'running'`)
         .get(workspaceId).count > 0;
+    const getRunningScheduledRun = (workspaceId) => {
+        markStaleRunningRuns(workspaceId);
+        const row = db
+            .prepare(`SELECT *
+         FROM dream_runs
+         WHERE workspace_id = ?
+           AND trigger = 'scheduled'
+           AND status = 'running'
+         ORDER BY started_at ASC, id ASC
+         LIMIT 1`)
+            .get(workspaceId);
+        return row ? toDreamRunRecord(row) : undefined;
+    };
     const getRun = (runId) => {
         const row = db.prepare('SELECT * FROM dream_runs WHERE id = ? LIMIT 1').get(runId);
         if (row?.status === 'running') {
@@ -130,6 +143,11 @@ export const createDreamRunStore = (db) => {
                WHEN trigger = 'scheduled' THEN started_at ELSE NULL
              END
            ) AS last_scheduled_at,
+           MIN(
+             CASE
+               WHEN trigger = 'scheduled' AND status = 'running' THEN id ELSE NULL
+             END
+           ) AS running_scheduled_run_id,
            (
              SELECT COUNT(*)
              FROM messages
@@ -145,6 +163,7 @@ export const createDreamRunStore = (db) => {
             hasRunningRun: row.running_count > 0,
             lastScheduledAt: row.last_scheduled_at,
             pendingMessageCount: row.pending_message_count,
+            runningScheduledRunId: row.running_scheduled_run_id,
         };
     };
     const createRun = (input) => {
@@ -213,6 +232,7 @@ export const createDreamRunStore = (db) => {
         createRun,
         deleteWorkspaceDreamRuns,
         getScheduleState,
+        getRunningScheduledRun,
         getRun,
         listInputMessages,
         listRuns,

package/dist/src/server/team-memory-dream-runner.d.ts

@@ -1,9 +1,10 @@
-import type { DreamRunRecord, DreamRunTrigger } from './team-memory-dream-store.js';
+import { type DreamRunRecord, type DreamRunTrigger } from './team-memory-dream-store.js';
 interface DreamStorePort {
     createRun: (input: {
         trigger: DreamRunTrigger;
         workspaceId: string;
     }) => DreamRunRecord;
+    getRunningScheduledRun: (workspaceId: string) => DreamRunRecord | undefined;
     markFailed: (runId: string, error: string, fallback?: DreamRunRecord | undefined) => DreamRunRecord;
 }
 export interface TeamMemoryDreamRunner {
@@ -11,8 +12,16 @@ export interface TeamMemoryDreamRunner {
     runScheduled: (workspaceId: string) => Promise<DreamRunRecord>;
 }
 export declare const createTeamMemoryDreamRunner: (deps: {
+    applyScheduledRun: (workspaceId: string, runId: string, rawOps: unknown) => DreamRunRecord;
+    buildScheduledInput: (workspaceId: string, run: DreamRunRecord) => {
+        prompt: string;
+    };
     dreamStore: DreamStorePort;
     deliverToOrchestrator: (workspaceId: string, text: string) => Promise<void>;
+    executeScheduledDream: (input: {
+        prompt: string;
+        workspaceId: string;
+    }) => Promise<unknown>;
     scheduleExport: (workspaceId: string) => void;
 }) => TeamMemoryDreamRunner;
 export {};

package/dist/src/server/team-memory-dream-runner.js

@@ -1,15 +1,19 @@
 import { buildDreamMaintenancePayload } from './team-memory-dream-prompt.js';
-import { DreamRunAlreadyRunningError } from './team-memory-dream-store.js';
+import { DreamRunAlreadyRunningError, } from './team-memory-dream-store.js';
 const truncateError = (value) => [...value].slice(0, 1000).join('');
 export const createTeamMemoryDreamRunner = (deps) => {
     const runningWorkspaceIds = new Set();
-    const run = async (workspaceId, trigger) => {
+    const createOrReuseRun = (workspaceId, trigger) => trigger === 'scheduled'
+        ? (deps.dreamStore.getRunningScheduledRun(workspaceId) ??
+            deps.dreamStore.createRun({ trigger, workspaceId }))
+        : deps.dreamStore.createRun({ trigger, workspaceId });
+    const runManual = async (workspaceId) => {
         if (runningWorkspaceIds.has(workspaceId))
             throw new DreamRunAlreadyRunningError(workspaceId);
         runningWorkspaceIds.add(workspaceId);
         let runRecord;
         try {
-            runRecord = deps.dreamStore.createRun({ trigger, workspaceId });
+            runRecord = createOrReuseRun(workspaceId, 'manual');
             await deps.deliverToOrchestrator(workspaceId, buildDreamMaintenancePayload(runRecord));
             deps.scheduleExport(workspaceId);
             return runRecord;
@@ -26,8 +30,33 @@ export const createTeamMemoryDreamRunner = (deps) => {
             runningWorkspaceIds.delete(workspaceId);
         }
     };
+    const runScheduled = async (workspaceId) => {
+        if (runningWorkspaceIds.has(workspaceId))
+            throw new DreamRunAlreadyRunningError(workspaceId);
+        runningWorkspaceIds.add(workspaceId);
+        let runRecord;
+        try {
+            runRecord = createOrReuseRun(workspaceId, 'scheduled');
+            const input = deps.buildScheduledInput(workspaceId, runRecord);
+            const raw = await deps.executeScheduledDream({ prompt: input.prompt, workspaceId });
+            const completed = deps.applyScheduledRun(workspaceId, runRecord.id, raw);
+            deps.scheduleExport(workspaceId);
+            return completed;
+        }
+        catch (error) {
+            if (!runRecord)
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            const failed = deps.dreamStore.markFailed(runRecord.id, truncateError(message), runRecord);
+            deps.scheduleExport(workspaceId);
+            return failed;
+        }
+        finally {
+            runningWorkspaceIds.delete(workspaceId);
+        }
+    };
     return {
-        runManual: (workspaceId) => run(workspaceId, 'manual'),
-        runScheduled: (workspaceId) => run(workspaceId, 'scheduled'),
+        runManual,
+        runScheduled,
     };
 };

package/dist/src/server/team-memory-dream-scheduler.js

@@ -77,9 +77,9 @@ export const createTeamMemoryDreamScheduler = (deps) => {
                         if (tickNow - idleSince < idleDebounceMs)
                             continue;
                         const state = deps.getScheduleState(workspace.id);
-                        if (state.hasRunningRun)
+                        if (state.hasRunningRun && !state.runningScheduledRunId)
                             continue;
-                        if (state.pendingMessageCount < minMessages)
+                        if (!state.runningScheduledRunId && state.pendingMessageCount < minMessages)
                             continue;
                         const effectiveFloorMs = floorMs *
                             2 **

package/dist/src/server/team-memory-dream-store.d.ts

@@ -1,7 +1,7 @@
 import type { Database } from 'better-sqlite3';
 export { DreamRunValidationError } from './team-memory-dream-ops.js';
 export { DreamRunNotFoundError, DreamRunRevertDataError, DreamRunRevertStatusError, } from './team-memory-dream-reverter.js';
-export { DREAM_RUNNING_STALE_MS, DREAM_STALE_ERROR, DreamRunAlreadyRunningError, DreamWorkspaceMissingError, } from './team-memory-dream-run-store.js';
+export { DREAM_NO_ACTIVE_ORCHESTRATOR_ERROR_PREFIX, DREAM_RUNNING_STALE_MS, DREAM_STALE_ERROR, DreamRunAlreadyRunningError, DreamWorkspaceMissingError, } from './team-memory-dream-run-store.js';
 export type { DreamMessageInput, DreamRunRecord, DreamRunReport, DreamRunRevertBlob, DreamRunStatus, DreamRunTrigger, DreamScheduleState, } from './team-memory-dream-types.js';
 export declare const createTeamMemoryDreamStore: (db: Database) => {
     revertRun: (workspaceId: string, runId: string) => import("./team-memory-dream-types.js").DreamRunRecord;
@@ -12,6 +12,7 @@ export declare const createTeamMemoryDreamStore: (db: Database) => {
     }) => import("./team-memory-dream-types.js").DreamRunRecord;
     deleteWorkspaceDreamRuns: (workspaceId: string) => void;
     getScheduleState: (workspaceId: string) => import("./team-memory-dream-types.js").DreamScheduleState;
+    getRunningScheduledRun: (workspaceId: string) => import("./team-memory-dream-types.js").DreamRunRecord | undefined;
     getRun: (runId: string) => import("./team-memory-dream-types.js").DreamRunRecord | undefined;
     listInputMessages: (workspaceId: string, from: number | null, to: number | null) => import("./team-memory-dream-types.js").DreamMessageInput[];
     listRuns: (workspaceId: string, limit?: number) => import("./team-memory-dream-types.js").DreamRunRecord[];

package/dist/src/server/team-memory-dream-store.js

@@ -3,7 +3,7 @@ import { createDreamRunReverter } from './team-memory-dream-reverter.js';
 import { createDreamRunStore } from './team-memory-dream-run-store.js';
 export { DreamRunValidationError } from './team-memory-dream-ops.js';
 export { DreamRunNotFoundError, DreamRunRevertDataError, DreamRunRevertStatusError, } from './team-memory-dream-reverter.js';
-export { DREAM_RUNNING_STALE_MS, DREAM_STALE_ERROR, DreamRunAlreadyRunningError, DreamWorkspaceMissingError, } from './team-memory-dream-run-store.js';
+export { DREAM_NO_ACTIVE_ORCHESTRATOR_ERROR_PREFIX, DREAM_RUNNING_STALE_MS, DREAM_STALE_ERROR, DreamRunAlreadyRunningError, DreamWorkspaceMissingError, } from './team-memory-dream-run-store.js';
 export const createTeamMemoryDreamStore = (db) => {
     const runStore = createDreamRunStore(db);
     const applier = createDreamOperationApplier(db);

package/dist/src/server/team-memory-dream-types.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryKind } from '../shared/team-memory.js';
+import type { MemoryKind, MemoryProcedureRef } from '../shared/team-memory.js';
 import type { MemorySource, MemorySourceType, MemoryStatus } from './team-memory-store.js';
 export type DreamRunTrigger = 'manual' | 'scheduled';
 export type DreamRunStatus = 'running' | 'completed' | 'failed' | 'reverted';
@@ -31,6 +31,9 @@ export interface MemoryEntryRow {
     kind: MemoryKind;
     last_injected_at: number | null;
     pinned: number;
+    ref_id: string | null;
+    ref_title: string | null;
+    ref_type: MemoryProcedureRef['type'] | null;
     scope: 'workspace' | 'user';
     source: MemorySource;
     status: MemoryStatus;
@@ -76,6 +79,7 @@ export interface DreamScheduleState {
     hasRunningRun: boolean;
     lastScheduledAt: number | null;
     pendingMessageCount: number;
+    runningScheduledRunId: string | null;
 }
 export interface DreamMessageInput {
     artifacts: string | null;

package/dist/src/server/team-memory-export.js

@@ -55,6 +55,13 @@ const formatEntryLine = (entry) => {
         labels.push('pinned');
     if (entry.disabled)
         labels.push('disabled');
+    if (entry.scope === 'user')
+        labels.push('scope: user');
+    if (entry.procedureRef) {
+        labels.push(`ref: ${entry.procedureRef.type}:${entry.procedureRef.id}`);
+        if (entry.procedureRef.title)
+            labels.push(`ref_title: ${entry.procedureRef.title}`);
+    }
     labels.push(`source: ${entry.source}`);
     const source = entry.sources[0];
     if (source?.actorNameSnapshot)

package/dist/src/server/team-memory-http-serializers.d.ts

@@ -9,6 +9,11 @@ export declare const serializeMemoryEntry: (entry: MemoryEntryWithSources) => {
     kind: "fact" | "preference" | "decision" | "pitfall" | "procedure_ref";
     last_injected_at: number | null;
     pinned: boolean;
+    procedure_ref: {
+        id: string;
+        title: string | null;
+        type: "workflow" | "skill" | "procedure" | "template" | "doc";
+    } | null;
     scope: "workspace" | "user";
     source: import("./team-memory-store.js").MemorySource;
     sources: {
@@ -41,6 +46,11 @@ export declare const serializeMemorySearchResult: (entry: MemorySearchResult) =>
     kind: "fact" | "preference" | "decision" | "pitfall" | "procedure_ref";
     last_injected_at: number | null;
     pinned: boolean;
+    procedure_ref: {
+        id: string;
+        title: string | null;
+        type: "workflow" | "skill" | "procedure" | "template" | "doc";
+    } | null;
     scope: "workspace" | "user";
     source: import("./team-memory-store.js").MemorySource;
     sources: {
@@ -76,6 +86,11 @@ export declare const serializeMemoryInjection: (injection: MemoryInjectionWithMe
         kind: "fact" | "preference" | "decision" | "pitfall" | "procedure_ref";
         last_injected_at: number | null;
         pinned: boolean;
+        procedure_ref: {
+            id: string;
+            title: string | null;
+            type: "workflow" | "skill" | "procedure" | "template" | "doc";
+        } | null;
         scope: "workspace" | "user";
         source: import("./team-memory-store.js").MemorySource;
         sources: {

package/dist/src/server/team-memory-http-serializers.js

@@ -21,6 +21,13 @@ export const serializeMemoryEntry = (entry) => ({
     kind: entry.kind,
     last_injected_at: entry.lastInjectedAt,
     pinned: entry.pinned,
+    procedure_ref: entry.procedureRef
+        ? {
+            id: entry.procedureRef.id,
+            title: entry.procedureRef.title,
+            type: entry.procedureRef.type,
+        }
+        : null,
     scope: entry.scope,
     source: entry.source,
     sources: entry.sources.map(serializeMemorySource),

package/dist/src/server/team-memory-provider.d.ts

@@ -0,0 +1,33 @@
+import type { MemoryEntryWithSources, MemorySearchOptions, MemorySearchResult } from './team-memory-store.js';
+export interface DispatchMemoryRetrievalInput {
+    taskText: string;
+    workerDescription: string;
+    workspaceId: string;
+}
+export interface MemoryProviderDiagnostics {
+    provider: 'local_sqlite';
+    retrieval: {
+        backend: Array<'fts_unicode' | 'fts_trigram' | 'like'>;
+        fallback: 'sqlite_only';
+        semantic_provider: 'not_configured';
+    };
+}
+export interface TeamMemoryProvider {
+    diagnostics: () => MemoryProviderDiagnostics;
+    listDigestEntries: (workspaceId: string, options?: {
+        limit?: number;
+    }) => MemoryEntryWithSources[];
+    retrieveDispatchEntries: (input: DispatchMemoryRetrievalInput) => MemorySearchResult[];
+    searchEntries: (workspaceId: string, query: string, options?: MemorySearchOptions) => MemorySearchResult[];
+}
+interface LocalMemoryProviderStore {
+    listDigestEntries: (workspaceId: string, options?: {
+        limit?: number;
+        scopes?: Array<'workspace' | 'user'>;
+    }) => MemoryEntryWithSources[];
+    searchEntries: (workspaceId: string, query: string, options?: MemorySearchOptions) => MemorySearchResult[];
+}
+export declare const createLocalTeamMemoryProvider: ({ memoryStore, }: {
+    memoryStore: LocalMemoryProviderStore;
+}) => TeamMemoryProvider;
+export {};

package/dist/src/server/team-memory-provider.js

@@ -0,0 +1,54 @@
+import { buildDispatchQueries, DISPATCH_MEMORY_CANDIDATE_LIMIT, mergeSearchResults, } from './team-memory-digest.js';
+export const createLocalTeamMemoryProvider = ({ memoryStore, }) => {
+    const searchRelevantEntries = (workspaceId, queries) => mergeSearchResults(queries.flatMap((query) => memoryStore.searchEntries(workspaceId, query, {
+        limit: DISPATCH_MEMORY_CANDIDATE_LIMIT,
+        scopes: ['workspace', 'user'],
+        statuses: ['active'],
+    })));
+    return {
+        diagnostics: () => ({
+            provider: 'local_sqlite',
+            retrieval: {
+                backend: ['fts_unicode', 'fts_trigram', 'like'],
+                fallback: 'sqlite_only',
+                semantic_provider: 'not_configured',
+            },
+        }),
+        listDigestEntries: (workspaceId, options) => {
+            const limit = Math.max(0, Math.trunc(options?.limit ?? 20));
+            const userLimit = limit <= 1 ? 0 : Math.min(4, Math.max(1, Math.floor(limit / 5)));
+            const workspaceLimit = Math.max(0, limit - userLimit);
+            return [
+                ...(workspaceLimit > 0
+                    ? memoryStore.listDigestEntries(workspaceId, {
+                        limit: workspaceLimit,
+                        scopes: ['workspace'],
+                    })
+                    : []),
+                ...(userLimit > 0
+                    ? memoryStore.listDigestEntries(workspaceId, {
+                        limit: userLimit,
+                        scopes: ['user'],
+                    })
+                    : []),
+            ];
+        },
+        retrieveDispatchEntries({ taskText, workerDescription, workspaceId }) {
+            const taskEntries = searchRelevantEntries(workspaceId, buildDispatchQueries(taskText, 8));
+            const roleEntries = searchRelevantEntries(workspaceId, buildDispatchQueries(workerDescription, 6));
+            const roleMatches = new Map(roleEntries.map((entry) => [entry.id, entry]));
+            if (taskEntries.length === 0)
+                return [];
+            return taskEntries.map((entry) => {
+                const roleMatch = roleMatches.get(entry.id);
+                if (!roleMatch)
+                    return entry;
+                return {
+                    ...entry,
+                    score: Math.min(entry.score, roleMatch.score),
+                };
+            });
+        },
+        searchEntries: (workspaceId, query, options) => memoryStore.searchEntries(workspaceId, query, options),
+    };
+};

package/dist/src/server/team-memory-store.d.ts

@@ -1,5 +1,5 @@
 import type { Database } from 'better-sqlite3';
-import { type MemoryKind } from '../shared/team-memory.js';
+import { type MemoryKind, type MemoryProcedureRef, type MemoryScope } from '../shared/team-memory.js';
 import type { AgentSummary } from '../shared/types.js';
 export type MemoryStatus = 'active' | 'candidate' | 'archived' | 'rejected';
 export type MemorySource = 'manual' | 'dream';
@@ -20,7 +20,8 @@ export interface MemoryEntryRecord {
     kind: MemoryKind;
     lastInjectedAt: number | null;
     pinned: boolean;
-    scope: 'workspace' | 'user';
+    procedureRef: MemoryProcedureRef | null;
+    scope: MemoryScope;
     source: MemorySource;
     status: MemoryStatus;
     tags: string[];
@@ -52,7 +53,9 @@ export interface AddMemoryEntryInput {
     body: string;
     confidence?: number | null;
     kind: MemoryKind;
+    procedureRef?: MemoryProcedureRef | null;
     source?: MemorySource;
+    scope?: MemoryScope;
     tags?: string[];
     workspaceId: string;
 }
@@ -66,14 +69,17 @@ export interface LogMemoryInjectionsInput {
 export interface MemorySearchOptions {
     includeDisabled?: boolean;
     limit?: number;
+    scopes?: MemoryScope[];
     statuses?: MemoryStatus[];
 }
 export interface MemoryListOptions {
     limit?: number;
+    scopes?: MemoryScope[];
     statuses?: MemoryStatus[];
 }
 export interface MemoryDigestOptions {
     limit?: number;
+    scopes?: MemoryScope[];
 }
 export interface MemoryInjectionWithMemory {
     contextType: MemoryInjectionContext;
@@ -105,8 +111,9 @@ export declare const createTeamMemoryStore: (db: Database) => {
     getEntryWithSources: (workspaceId: string, memoryId: string) => MemoryEntryWithSources | undefined;
     listDigestEntries: (workspaceId: string, options?: MemoryDigestOptions) => MemoryEntryWithSources[];
     listExportEntries: (workspaceId: string) => MemoryEntryWithSources[];
-    listAllEntries: (workspaceId: string) => MemoryEntryWithSources[];
+    listAllEntries: (workspaceId: string, options?: Pick<MemoryListOptions, "scopes">) => MemoryEntryWithSources[];
     listEntries: (workspaceId: string, options?: MemoryListOptions) => MemoryEntryWithSources[];
+    listInjections: (workspaceId: string, limit?: number) => MemoryInjectionWithMemory[];
     listInjectionsForDispatch: (workspaceId: string, dispatchId: string) => MemoryInjectionWithMemory[];
     logInjections: (input: LogMemoryInjectionsInput) => `${string}-${string}-${string}-${string}-${string}`[];
     rejectCandidate: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;