@karmaniverous/jeeves-meta 0.16.0 → 0.16.2

package/dist/queue/index.d.ts

@@ -1,26 +1,18 @@
 /**
- * Hybrid 3-layer synthesis queue.
+ * Synthesis queue.
  *
  * Layer 1: Current — the single item currently executing (at most one).
- * Layer 2: Overrides — items manually enqueued via POST /synthesize with path.
- *          FIFO among overrides, ahead of automatic candidates.
- * Layer 3: Automatic — computed on read, not persisted. All metas with a
- *          pending phase, ranked by scheduler priority.
- *
- * Legacy: `pending` array is the union of overrides + automatic.
+ * Layer 2: Pending — items enqueued via POST /synthesize (targeted) or
+ *          scheduler tick (automatic). FIFO, ahead of automatic candidates.
+ * Layer 3: Automatic — computed on read (GET /queue), not persisted. All
+ *          metas with a pending phase, ranked by scheduler priority.
  *
  * @module queue
  */
 import type { Logger } from 'pino';
 import type { PhaseName } from '../schema/meta.js';
-/** A queued synthesis work item. */
-export interface QueueItem {
-    path: string;
-    priority: boolean;
-    enqueuedAt: string;
-}
-/** An override entry in the explicit queue layer. */
-export interface OverrideEntry {
+/** An entry in the synthesis queue. */
+export interface QueueEntry {
     path: string;
     enqueuedAt: string;
 }
@@ -40,69 +32,35 @@ export interface QueueState {
     depth: number;
     items: Array<{
         path: string;
-        priority: boolean;
         enqueuedAt: string;
     }>;
 }
 /**
- * Hybrid 3-layer synthesis queue.
+ * Synthesis queue.
  *
- * Only one synthesis runs at a time. Override items (explicit triggers)
- * take priority over automatic candidates.
+ * Only one synthesis runs at a time. Explicitly enqueued items
+ * take priority over automatic (computed-on-read) candidates.
  */
 export declare class SynthesisQueue {
-    /** Legacy queue (used by processQueue for backward compat). */
-    private queue;
-    private currentItem;
+    private entries;
+    private currentPhaseItem;
     private processing;
     private logger;
     private onEnqueueCallback;
-    /** Explicit override entries (3-layer model). */
-    private overrideEntries;
-    /** Currently executing item with phase info (3-layer model). */
-    private currentPhaseItem;
     constructor(logger: Logger);
     /** Set a callback to invoke when a new (non-duplicate) item is enqueued. */
     onEnqueue(callback: () => void): void;
     /**
-     * Add an explicit override entry (from POST /synthesize with path).
+     * Add an entry to the queue.
      * Deduped by path. Returns position and whether already queued.
      */
-    enqueueOverride(path: string): EnqueueResult;
-    /** Dequeue the next override entry, or undefined if empty. */
-    dequeueOverride(): OverrideEntry | undefined;
-    /** Get all override entries (shallow copy). */
-    get overrides(): OverrideEntry[];
-    /** Clear all override entries. Returns count removed. */
-    clearOverrides(): number;
-    /** Check if a path is in the override layer. */
-    hasOverride(path: string): boolean;
-    /** Set the currently executing phase item. */
-    setCurrentPhase(path: string, phase: PhaseName): void;
-    /** Clear the current phase item. */
-    clearCurrentPhase(): void;
-    /** The currently executing phase item, or null. */
-    get currentPhase(): CurrentItem | null;
-    /**
-     * Add a path to the synthesis queue.
-     *
-     * @param path - Meta path to synthesize.
-     * @param priority - If true, insert at front of queue.
-     * @returns Position and whether the path was already queued.
-     */
-    enqueue(path: string, priority?: boolean): EnqueueResult;
-    /** Remove and return the next item from the queue. */
-    dequeue(): QueueItem | undefined;
-    /** Mark the currently-running synthesis as complete. */
-    complete(): void;
+    enqueue(path: string): EnqueueResult;
+    /** Dequeue the next entry, or undefined if empty. */
+    dequeue(): QueueEntry | undefined;
+    /** Get all queued entries (shallow copy). */
+    get items(): QueueEntry[];
     /** Number of items waiting in the queue (excludes current). */
     get depth(): number;
-    /** The item currently being synthesized, or null. */
-    get current(): QueueItem | null;
-    /** A shallow copy of the queued items. */
-    get items(): QueueItem[];
-    /** A shallow copy of the pending items (alias for items). */
-    get pending(): QueueItem[];
     /**
      * Remove all pending items from the queue.
      * Does not affect the currently-running item.
@@ -112,16 +70,17 @@ export declare class SynthesisQueue {
     clear(): number;
     /** Check whether a path is in the queue or currently being synthesized. */
     has(path: string): boolean;
-    /** Get the 0-indexed position of a path in the queue. */
-    getPosition(path: string): number | null;
-    /** Dequeue the next item: overrides first, then legacy queue. */
-    private nextItem;
+    /** Set the currently executing phase item. */
+    setCurrentPhase(path: string, phase: PhaseName): void;
+    /** Clear the current phase item. */
+    clearCurrentPhase(): void;
+    /** The currently executing phase item, or null. */
+    get currentPhase(): CurrentItem | null;
     /** Return a snapshot of queue state for the /status endpoint. */
     getState(): QueueState;
     /**
-     * Process queued items one at a time until all queues are empty.
+     * Process queued items one at a time until the queue is empty.
      *
-     * Override entries are processed first (FIFO), then legacy queue items.
      * Re-entry is prevented: if already processing, the call returns
      * immediately. Errors are logged and do not block subsequent items.
      *

package/dist/routes/queue.d.ts

@@ -1,8 +1,8 @@
 /**
  * Queue management and abort routes.
  *
- * - GET /queue — 3-layer queue model (current, overrides, automatic, pending)
- * - POST /queue/clear — remove override entries only
+ * - GET /queue — 3-layer queue model (current, pending, automatic)
+ * - POST /queue/clear — remove pending entries
  * - POST /synthesize/abort — abort the current synthesis
  *
  * @module routes/queue

package/dist/schema/config.d.ts

@@ -49,6 +49,10 @@ export declare const serviceConfigSchema: z.ZodObject<{
         crossRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
         parentDepth: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>>>;
+    workspaceDir: z.ZodOptional<z.ZodString>;
+    stagingRetries: z.ZodDefault<z.ZodNumber>;
+    stagingRetryDelayMs: z.ZodDefault<z.ZodNumber>;
+    previewDeltaFilesCap: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 /** Inferred type for service configuration. */
 export type ServiceConfig = z.infer<typeof serviceConfigSchema>;

package/package.json

@@ -8,7 +8,7 @@
   },
   "dependencies": {
     "@karmaniverous/jeeves": "^0.5.12",
-    "@karmaniverous/jeeves-meta-core": "^0.2.0",
+    "@karmaniverous/jeeves-meta-core": "^0.2.1",
     "commander": "^14",
     "croner": "^10",
     "fastify": "^5.8",
@@ -110,5 +110,5 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "0.16.0"
+  "version": "0.16.2"
 }