@karmaniverous/jeeves-meta 0.15.12 → 0.16.1

package/dist/index.js

@@ -1271,12 +1271,6 @@ const autoSeedRuleSchema = z.object({
     crossRefs: z.array(z.string()).optional(),
     /** Walk up this many extra parent levels from the matched file's directory. Default 0. */
     parentDepth: z.number().int().min(0).optional(),
-    /** Per-category timeout override for the architect phase (seconds, min 30). */
-    architectTimeout: z.number().int().min(30).optional(),
-    /** Per-category timeout override for the builder phase (seconds, min 30). */
-    builderTimeout: z.number().int().min(30).optional(),
-    /** Per-category timeout override for the critic phase (seconds, min 30). */
-    criticTimeout: z.number().int().min(30).optional(),
 });
 /** Zod schema for jeeves-meta service configuration (superset of MetaConfig). */
 const serviceConfigSchema = metaConfigSchema.extend({
@@ -1459,7 +1453,7 @@ class SpawnTimeoutError extends Error {
  * @module executor/GatewayExecutor
  */
 const DEFAULT_POLL_INTERVAL_MS = 5000;
-const DEFAULT_TIMEOUT_MS$1 = 600_000; // 10 minutes
+const DEFAULT_SAFETY_VALVE_MS = 3_600_000; // 1 hour fallback
 /**
  * MetaExecutor that spawns OpenClaw sessions via the gateway's
  * `/tools/invoke` endpoint.
@@ -1490,6 +1484,46 @@ class GatewayExecutor {
             /* best-effort cleanup */
         }
     }
+    /** Read and clean up the staging output file. Returns content or undefined if absent. */
+    readStagingFile(outputPath) {
+        if (!existsSync(outputPath))
+            return undefined;
+        try {
+            return readFileSync(outputPath, 'utf8');
+        }
+        finally {
+            this.cleanupOutputFile(outputPath);
+        }
+    }
+    /** Extract plain text from a message content field, skipping ANNOUNCE_SKIP sentinels. */
+    static extractMessageText(content) {
+        if (!content)
+            return undefined;
+        const text = typeof content === 'string'
+            ? content
+            : Array.isArray(content)
+                ? content
+                    .filter((b) => b.type === 'text' && b.text)
+                    .map((b) => b.text)
+                    .join('\n')
+                : '';
+        return text && text.trim() !== 'ANNOUNCE_SKIP' ? text : undefined;
+    }
+    /**
+     * Check history messages for timeout detection.
+     *
+     * Does NOT determine completion — session completion is authoritative
+     * (via sessions_list). History stop reasons can false-positive on
+     * sessions_yield artifacts (#200).
+     */
+    static checkHistoryCompletion(messages) {
+        if (messages.length === 0)
+            return { timedOut: false };
+        const last = messages[messages.length - 1];
+        if (last.role !== 'assistant' || !last.stopReason)
+            return { timedOut: false };
+        return { timedOut: last.stopReason === 'timeout' };
+    }
     /** Invoke a gateway tool via the /tools/invoke HTTP endpoint. */
     async invoke(tool, args, sessionKey) {
         const headers = {
@@ -1516,7 +1550,13 @@ class GatewayExecutor {
         }
         return data;
     }
-    /** Look up session metadata (tokens, completion status) via sessions_list. */
+    /**
+     * Look up session metadata (tokens, completion status) via sessions_list.
+     *
+     * Detects gateway-side timeout (`status: "timeout"`) and killed sessions
+     * (`status: "killed"`) as completed, with a `timedOut` flag to distinguish
+     * timeout from normal completion.
+     */
     async getSessionInfo(sessionKey) {
         try {
             const result = await this.invoke('sessions_list', {
@@ -1532,13 +1572,18 @@ class GatewayExecutor {
                 // With limit=200 this is reliable; a false positive here only
                 // means we read the output file slightly early (still correct
                 // if the file exists).
-                return { completed: true };
+                return { completed: true, timedOut: false };
             }
-            const done = match.status === 'completed' || match.status === 'done';
-            return { tokens: match.totalTokens, completed: done };
+            const status = match.status;
+            const done = status === 'completed' ||
+                status === 'done' ||
+                status === 'timeout' ||
+                status === 'killed';
+            const timedOut = status === 'timeout';
+            return { tokens: match.totalTokens, completed: done, timedOut };
         }
         catch {
-            return { completed: false };
+            return { completed: false, timedOut: false };
         }
     }
     /** Whether this executor has been aborted by the operator. */
@@ -1549,12 +1594,38 @@ class GatewayExecutor {
     abort() {
         this.controller.abort();
     }
+    /**
+     * Query the gateway's configured subagent run timeout.
+     *
+     * Returns the value in milliseconds, or `undefined` if the query fails
+     * or the value is absent/zero (no timeout configured).
+     */
+    async queryGatewayRunTimeout() {
+        try {
+            const result = await this.invoke('session_status', {});
+            const details = (result.result?.details ?? result.result ?? {});
+            const runTimeoutSeconds = details.runTimeoutSeconds ??
+                details.timeout;
+            if (typeof runTimeoutSeconds === 'number' && runTimeoutSeconds > 0) {
+                return runTimeoutSeconds * 1000;
+            }
+        }
+        catch {
+            // Gateway unreachable or field not exposed — fall back to default
+        }
+        return undefined;
+    }
     async spawn(task, options) {
         // Fresh controller for each spawn call
         this.controller = new AbortController();
-        const timeoutSeconds = options?.timeout ?? DEFAULT_TIMEOUT_MS$1 / 1000;
-        const timeoutMs = timeoutSeconds * 1000;
-        const deadline = Date.now() + timeoutMs;
+        // Safety-valve deadline: gateway's runTimeoutSeconds + 60s buffer,
+        // defaulting to 1 hour if the gateway value is 0/absent/query fails.
+        // This is a circuit breaker, not a timeout mechanism.
+        const gatewayTimeoutMs = await this.queryGatewayRunTimeout();
+        const safetyValveMs = gatewayTimeoutMs
+            ? gatewayTimeoutMs + 60_000
+            : DEFAULT_SAFETY_VALVE_MS;
+        const safetyDeadline = Date.now() + safetyValveMs;
         // Ensure workspace dir exists
         if (!existsSync(this.workspaceDir)) {
             mkdirSync(this.workspaceDir, { recursive: true });
@@ -1576,7 +1647,6 @@ class GatewayExecutor {
         const spawnResult = await this.invoke('sessions_spawn', {
             task: taskWithOutput,
             label,
-            runTimeoutSeconds: timeoutSeconds,
             ...(options?.thinking ? { thinking: options.thinking } : {}),
             ...(options?.model ? { model: options.model } : {}),
         });
@@ -1588,9 +1658,18 @@ class GatewayExecutor {
             throw new Error('Gateway sessions_spawn returned no sessionKey: ' +
                 JSON.stringify(spawnResult));
         }
-        // Step 2: Poll for completion via sessions_history
+        // Step 2: Poll for completion — gateway owns the subagent lifecycle.
+        // Loop exits via: (a) completion detection, (b) abort signal,
+        // (c) gateway-side timeout detection, or (d) safety-valve circuit breaker.
         await sleepAsync(3000);
-        while (Date.now() < deadline) {
+        while (true) {
+            // Safety-valve circuit breaker
+            if (Date.now() >= safetyDeadline) {
+                this.cleanupOutputFile(outputPath);
+                throw new SpawnTimeoutError('Safety-valve deadline exceeded (' +
+                    safetyValveMs.toString() +
+                    'ms) — gateway timeout may be misconfigured', outputPath);
+            }
             // Check for abort before each poll iteration
             if (this.controller.signal.aborted) {
                 this.cleanupOutputFile(outputPath);
@@ -1606,63 +1685,51 @@ class GatewayExecutor {
                     historyResult.result?.messages ??
                     [];
                 const msgArray = messages;
-                // Check 1: terminal stop reason in history
-                let historyDone = false;
-                if (msgArray.length > 0) {
-                    const lastMsg = msgArray[msgArray.length - 1];
-                    if (lastMsg.role === 'assistant' &&
-                        lastMsg.stopReason &&
-                        lastMsg.stopReason !== 'toolUse' &&
-                        lastMsg.stopReason !== 'error') {
-                        historyDone = true;
-                    }
-                }
+                // Check 1: history-based timeout detection (stop reason)
+                const { timedOut: historyTimedOut } = GatewayExecutor.checkHistoryCompletion(msgArray);
                 // Check 2: session completion status via sessions_list
+                // Gate on session completion only — history stop reasons can
+                // false-positive on sessions_yield artifacts (#200).
                 const sessionInfo = await this.getSessionInfo(sessionKey);
-                if (historyDone || sessionInfo.completed) {
+                const timedOut = sessionInfo.timedOut || historyTimedOut;
+                if (sessionInfo.completed) {
                     const tokens = sessionInfo.tokens;
-                    // Read output from file (sub-agent wrote it via Write tool)
-                    if (existsSync(outputPath)) {
-                        try {
-                            const output = readFileSync(outputPath, 'utf8');
+                    // Gateway-side timeout detected — check staging file for recovery
+                    if (timedOut) {
+                        const output = this.readStagingFile(outputPath);
+                        if (output !== undefined)
                             return { output, tokens };
-                        }
-                        finally {
-                            try {
-                                unlinkSync(outputPath);
-                            }
-                            catch {
-                                /* cleanup best-effort */
-                            }
-                        }
+                        // No output or partial output — throw for _state recovery (§3.16.6)
+                        throw new SpawnTimeoutError('Gateway-side timeout detected (session status: timeout)', outputPath);
                     }
+                    // Normal completion — read output from file
+                    const output = this.readStagingFile(outputPath);
+                    if (output !== undefined)
+                        return { output, tokens };
                     // Fallback: extract from message content if file wasn't written.
                     // Skip ANNOUNCE_SKIP sentinel messages — the real output is in
                     // a preceding assistant message (the file write).
                     for (let i = msgArray.length - 1; i >= 0; i--) {
                         const msg = msgArray[i];
-                        if (msg.role === 'assistant' && msg.content) {
-                            const text = typeof msg.content === 'string'
-                                ? msg.content
-                                : Array.isArray(msg.content)
-                                    ? msg.content
-                                        .filter((b) => b.type === 'text' && b.text)
-                                        .map((b) => b.text)
-                                        .join('\n')
-                                    : '';
-                            if (text && text.trim() !== 'ANNOUNCE_SKIP')
+                        if (msg.role === 'assistant') {
+                            const text = GatewayExecutor.extractMessageText(msg.content);
+                            if (text !== undefined)
                                 return { output: text, tokens };
                         }
                     }
                     return { output: '', tokens };
                 }
             }
-            catch {
+            catch (err) {
+                // Re-throw SpawnTimeoutError and SpawnAbortedError — only swallow transient poll failures
+                if (err instanceof SpawnTimeoutError ||
+                    err instanceof SpawnAbortedError) {
+                    throw err;
+                }
                 // Transient poll failure — keep trying
             }
             await sleepAsync(this.pollIntervalMs);
         }
-        throw new SpawnTimeoutError('Synthesis subprocess timed out after ' + timeoutMs.toString() + 'ms', outputPath);
     }
 }
 
@@ -2884,7 +2951,6 @@ async function runArchitect(node, currentMeta, phaseState, config, executor, wat
         const architectTask = buildArchitectTask(ctx, currentMeta, config);
         const result = await executor.spawn(architectTask, {
             thinking: config.thinking,
-            timeout: currentMeta._architectTimeout ?? config.architectTimeout,
             label: 'meta-architect',
         });
         const builderBrief = parseArchitectOutput(result.output);
@@ -2936,7 +3002,6 @@ async function runBuilder(node, currentMeta, phaseState, config, executor, watch
         const builderTask = buildBuilderTask(ctx, currentMeta, config);
         const result = await executor.spawn(builderTask, {
             thinking: config.thinking,
-            timeout: currentMeta._builderTimeout ?? config.builderTimeout,
             label: 'meta-builder',
         });
         const rawOutput = result.output;
@@ -3031,7 +3096,6 @@ async function runCritic(node, currentMeta, phaseState, config, executor, watche
         const criticTask = buildCriticTask(ctx, metaForCritic, config);
         const result = await executor.spawn(criticTask, {
             thinking: config.thinking,
-            timeout: currentMeta._criticTimeout ?? config.criticTimeout,
             label: 'meta-critic',
         });
         const feedback = parseCriticOutput(result.output);
@@ -3367,36 +3431,33 @@ class ProgressReporter {
 }
 
 /**
- * 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
  */
 const DEPTH_WARNING_THRESHOLD = 3;
+/** Strip trailing .meta suffix for consistent path comparison. */
+function normQueuePath(p) {
+    return p.endsWith('.meta') ? p.slice(0, -5).replace(/[/\\]$/, '') : p;
+}
 /**
- * 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.
  */
 class SynthesisQueue {
-    /** Legacy queue (used by processQueue for backward compat). */
-    queue = [];
-    currentItem = null;
+    entries = [];
+    currentPhaseItem = null;
     processing = false;
     logger;
     onEnqueueCallback = null;
-    /** Explicit override entries (3-layer model). */
-    overrideEntries = [];
-    /** Currently executing item with phase info (3-layer model). */
-    currentPhaseItem = null;
     constructor(logger) {
         this.logger = logger;
     }
@@ -3404,52 +3465,67 @@ class SynthesisQueue {
     onEnqueue(callback) {
         this.onEnqueueCallback = callback;
     }
-    // ── Override layer (3-layer model) ─────────────────────────────────
+    // ── Enqueue / dequeue ──────────────────────────────────────────────
     /**
-     * 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) {
+    enqueue(path) {
+        const norm = normQueuePath(path);
         // Check if currently executing
-        if (this.currentPhaseItem?.path === path ||
-            this.currentItem?.path === path) {
+        if (this.currentPhaseItem &&
+            normQueuePath(this.currentPhaseItem.path) === norm) {
             return { position: 0, alreadyQueued: true };
         }
-        // Check if already in overrides
-        const existing = this.overrideEntries.findIndex((e) => e.path === path);
+        // Check if already in queue
+        const existing = this.entries.findIndex((e) => normQueuePath(e.path) === norm);
         if (existing !== -1) {
             return { position: existing, alreadyQueued: true };
         }
-        this.overrideEntries.push({
+        this.entries.push({
             path,
             enqueuedAt: new Date().toISOString(),
         });
-        const position = this.overrideEntries.length - 1;
-        if (this.overrideEntries.length > DEPTH_WARNING_THRESHOLD) {
-            this.logger.warn({ depth: this.overrideEntries.length }, 'Override queue depth exceeds threshold');
+        const position = this.entries.length - 1;
+        if (this.entries.length > DEPTH_WARNING_THRESHOLD) {
+            this.logger.warn({ depth: this.entries.length }, 'Queue depth exceeds threshold');
         }
         this.onEnqueueCallback?.();
         return { position, alreadyQueued: false };
     }
-    /** Dequeue the next override entry, or undefined if empty. */
-    dequeueOverride() {
-        return this.overrideEntries.shift();
+    /** Dequeue the next entry, or undefined if empty. */
+    dequeue() {
+        return this.entries.shift();
     }
-    /** Get all override entries (shallow copy). */
-    get overrides() {
-        return [...this.overrideEntries];
+    /** Get all queued entries (shallow copy). */
+    get items() {
+        return [...this.entries];
     }
-    /** Clear all override entries. Returns count removed. */
-    clearOverrides() {
-        const count = this.overrideEntries.length;
-        this.overrideEntries = [];
+    /** Number of items waiting in the queue (excludes current). */
+    get depth() {
+        return this.entries.length;
+    }
+    /**
+     * Remove all pending items from the queue.
+     * Does not affect the currently-running item.
+     *
+     * @returns The number of items removed.
+     */
+    clear() {
+        const count = this.entries.length;
+        this.entries = [];
         return count;
     }
-    /** Check if a path is in the override layer. */
-    hasOverride(path) {
-        return this.overrideEntries.some((e) => e.path === path);
+    /** Check whether a path is in the queue or currently being synthesized. */
+    has(path) {
+        const norm = normQueuePath(path);
+        if (this.currentPhaseItem &&
+            normQueuePath(this.currentPhaseItem.path) === norm) {
+            return true;
+        }
+        return this.entries.some((e) => normQueuePath(e.path) === norm);
     }
-    // ── Current-item tracking (3-layer model) ──────────────────────────
+    // ── Current-item tracking ──────────────────────────────────────────
     /** Set the currently executing phase item. */
     setCurrentPhase(path, phase) {
         this.currentPhaseItem = {
@@ -3466,129 +3542,21 @@ class SynthesisQueue {
     get currentPhase() {
         return this.currentPhaseItem;
     }
-    // ── Legacy queue interface (preserved for backward compat) ─────────
-    /**
-     * 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, priority = false) {
-        if (this.currentItem?.path === path) {
-            return { position: 0, alreadyQueued: true };
-        }
-        const existingIndex = this.queue.findIndex((item) => item.path === path);
-        if (existingIndex !== -1) {
-            return { position: existingIndex, alreadyQueued: true };
-        }
-        const item = {
-            path,
-            priority,
-            enqueuedAt: new Date().toISOString(),
-        };
-        if (priority) {
-            this.queue.unshift(item);
-        }
-        else {
-            this.queue.push(item);
-        }
-        if (this.queue.length > DEPTH_WARNING_THRESHOLD) {
-            this.logger.warn({ depth: this.queue.length }, 'Queue depth exceeds threshold');
-        }
-        const position = this.queue.findIndex((i) => i.path === path);
-        this.onEnqueueCallback?.();
-        return { position, alreadyQueued: false };
-    }
-    /** Remove and return the next item from the queue. */
-    dequeue() {
-        const item = this.queue.shift();
-        if (item) {
-            this.currentItem = item;
-        }
-        return item;
-    }
-    /** Mark the currently-running synthesis as complete. */
-    complete() {
-        this.currentItem = null;
-    }
-    /** Number of items waiting in the queue (excludes current). */
-    get depth() {
-        return this.queue.length;
-    }
-    /** The item currently being synthesized, or null. */
-    get current() {
-        return this.currentItem;
-    }
-    /** A shallow copy of the queued items. */
-    get items() {
-        return [...this.queue];
-    }
-    /** A shallow copy of the pending items (alias for items). */
-    get pending() {
-        return [...this.queue];
-    }
-    /**
-     * Remove all pending items from the queue.
-     * Does not affect the currently-running item.
-     *
-     * @returns The number of items removed.
-     */
-    clear() {
-        const count = this.queue.length;
-        this.queue = [];
-        return count;
-    }
-    /** Check whether a path is in the queue or currently being synthesized. */
-    has(path) {
-        if (this.currentItem?.path === path)
-            return true;
-        if (this.currentPhaseItem?.path === path)
-            return true;
-        return (this.queue.some((item) => item.path === path) ||
-            this.overrideEntries.some((e) => e.path === path));
-    }
-    /** Get the 0-indexed position of a path in the queue. */
-    getPosition(path) {
-        // Check overrides first
-        const overrideIdx = this.overrideEntries.findIndex((e) => e.path === path);
-        if (overrideIdx !== -1)
-            return overrideIdx;
-        const index = this.queue.findIndex((item) => item.path === path);
-        return index === -1 ? null : index;
-    }
-    /** Dequeue the next item: overrides first, then legacy queue. */
-    nextItem() {
-        const override = this.dequeueOverride();
-        if (override)
-            return { path: override.path, source: 'override' };
-        const item = this.dequeue();
-        if (item)
-            return { path: item.path, source: 'legacy' };
-        return undefined;
-    }
+    // ── Queue state ────────────────────────────────────────────────────
     /** Return a snapshot of queue state for the /status endpoint. */
     getState() {
         return {
-            depth: this.queue.length + this.overrideEntries.length,
-            items: [
-                ...this.overrideEntries.map((e) => ({
-                    path: e.path,
-                    priority: true,
-                    enqueuedAt: e.enqueuedAt,
-                })),
-                ...this.queue.map((item) => ({
-                    path: item.path,
-                    priority: item.priority,
-                    enqueuedAt: item.enqueuedAt,
-                })),
-            ],
+            depth: this.entries.length,
+            items: this.entries.map((e) => ({
+                path: e.path,
+                enqueuedAt: e.enqueuedAt,
+            })),
         };
     }
+    // ── Processing ─────────────────────────────────────────────────────
     /**
-     * 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.
      *
@@ -3599,7 +3567,7 @@ class SynthesisQueue {
             return;
         this.processing = true;
         try {
-            let next = this.nextItem();
+            let next = this.dequeue();
             while (next) {
                 try {
                     await synthesizeFn(next.path);
@@ -3608,9 +3576,7 @@ class SynthesisQueue {
                     this.logger.error({ path: next.path, err }, 'Synthesis failed');
                 }
                 this.clearCurrentPhase();
-                if (next.source === 'legacy')
-                    this.complete();
-                next = this.nextItem();
+                next = this.dequeue();
             }
         }
         finally {
@@ -3944,12 +3910,6 @@ async function createMeta(ownerPath, options) {
         metaJson._crossRefs = options.crossRefs;
     if (options?.steer !== undefined)
         metaJson._steer = options.steer;
-    if (options?.architectTimeout !== undefined)
-        metaJson._architectTimeout = options.architectTimeout;
-    if (options?.builderTimeout !== undefined)
-        metaJson._builderTimeout = options.builderTimeout;
-    if (options?.criticTimeout !== undefined)
-        metaJson._criticTimeout = options.criticTimeout;
     const metaJsonPath = join(metaDir, 'meta.json');
     await writeFile(metaJsonPath, JSON.stringify(metaJson, null, 2) + '\n');
     return { metaDir, _id };
@@ -4025,9 +3985,6 @@ async function autoSeedPass(rules, watcher, logger) {
             candidates.set(dir, {
                 steer: rule.steer,
                 crossRefs: rule.crossRefs,
-                architectTimeout: rule.architectTimeout,
-                builderTimeout: rule.builderTimeout,
-                criticTimeout: rule.criticTimeout,
             });
         }
     }
@@ -4173,7 +4130,6 @@ class Scheduler {
             this.logger.debug({ backoffMultiplier: this.backoffMultiplier }, 'No ready phases found, increasing backoff');
             return;
         }
-        // Enqueue using the legacy queue path (backward compat with processQueue)
         this.queue.enqueue(candidate.path);
         this.logger.info({ path: candidate.path, phase: candidate.phase, band: candidate.band }, 'Enqueued phase candidate');
         // Opportunistic watcher restart detection
@@ -4597,7 +4553,7 @@ function registerMetasRoutes(app, deps) {
 /**
  * PATCH /metas/:path — update user-settable reserved properties on a meta.
  *
- * Supported fields: _steer, _emphasis, _depth, _crossRefs, _disabled, _architectTimeout, _builderTimeout, _criticTimeout.
+ * Supported fields: _steer, _emphasis, _depth, _crossRefs, _disabled.
  * Set a field to null to remove it. Unknown keys are rejected.
  *
  * @module routes/metasUpdate
@@ -4609,9 +4565,6 @@ const updateBodySchema = z
     _depth: z.union([z.number(), z.null()]).optional(),
     _crossRefs: z.union([z.array(z.string()), z.null()]).optional(),
     _disabled: z.union([z.boolean(), z.null()]).optional(),
-    _architectTimeout: z.union([z.number().int().min(30), z.null()]).optional(),
-    _builderTimeout: z.union([z.number().int().min(30), z.null()]).optional(),
-    _criticTimeout: z.union([z.number().int().min(30), z.null()]).optional(),
 })
     .strict();
 function registerMetasUpdateRoute(app, deps) {
@@ -4775,8 +4728,8 @@ function registerPreviewRoute(app, deps) {
 /**
  * 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
@@ -4786,24 +4739,24 @@ function registerQueueRoutes(app, deps) {
     const { queue } = deps;
     app.get(getEndpoint('queue').path, async () => {
         const currentPhase = queue.currentPhase;
-        const overrides = queue.overrides;
-        // Compute owedPhase for each override entry by reading meta state
-        const enrichedOverrides = await Promise.all(overrides.map(async (o) => {
+        const pending = queue.items;
+        // Compute owedPhase for each pending entry by reading meta state
+        const enrichedPending = await Promise.all(pending.map(async (entry) => {
             try {
-                const metaDir = resolveMetaDir(o.path);
+                const metaDir = resolveMetaDir(entry.path);
                 const meta = await readMetaJson(metaDir);
                 const ps = derivePhaseState(meta);
                 return {
-                    path: o.path,
+                    path: entry.path,
                     owedPhase: getOwedPhase(ps),
-                    enqueuedAt: o.enqueuedAt,
+                    enqueuedAt: entry.enqueuedAt,
                 };
             }
             catch {
                 return {
-                    path: o.path,
+                    path: entry.path,
                     owedPhase: null,
-                    enqueuedAt: o.enqueuedAt,
+                    enqueuedAt: entry.enqueuedAt,
                 };
             }
         }));
@@ -4824,21 +4777,6 @@ function registerQueueRoutes(app, deps) {
         catch {
             // If listing fails, automatic stays empty
         }
-        // Legacy: pending is the union of overrides + automatic + legacy queue items
-        const pendingItems = [
-            ...enrichedOverrides.map((o) => ({
-                path: o.path,
-                owedPhase: o.owedPhase,
-            })),
-            ...automatic.map((a) => ({
-                path: a.path,
-                owedPhase: a.owedPhase,
-            })),
-            ...queue.pending.map((item) => ({
-                path: item.path,
-                owedPhase: null,
-            })),
-        ];
         return {
             current: currentPhase
                 ? {
@@ -4846,58 +4784,45 @@ function registerQueueRoutes(app, deps) {
                     phase: currentPhase.phase,
                     startedAt: currentPhase.startedAt,
                 }
-                : queue.current
-                    ? {
-                        path: queue.current.path,
-                        phase: null,
-                        startedAt: queue.current.enqueuedAt,
-                    }
-                    : null,
-            overrides: enrichedOverrides,
+                : null,
+            pending: enrichedPending,
             automatic,
-            pending: pendingItems,
-            // Legacy state
-            state: queue.getState(),
         };
     });
     app.post(getEndpoint('queueClear').path, () => {
-        const removed = queue.clearOverrides();
+        const removed = queue.clear();
         return { cleared: removed };
     });
     app.post(getEndpoint('abort').path, async (_request, reply) => {
-        // Check 3-layer current first
         const currentPhase = queue.currentPhase;
-        const current = currentPhase ?? queue.current;
-        if (!current) {
+        if (!currentPhase) {
             return reply.status(200).send({ status: 'idle' });
         }
         // Abort the executor
         deps.executor?.abort();
-        const metaDir = resolveMetaDir(current.path);
-        const phase = currentPhase?.phase ?? null;
+        const metaDir = resolveMetaDir(currentPhase.path);
+        const { phase } = currentPhase;
         // Transition running phase to failed and write _error to meta.json
-        if (phase) {
-            try {
-                const meta = await readMetaJson(metaDir);
-                let ps = derivePhaseState(meta);
-                ps = phaseFailed(ps, phase);
-                const updated = {
-                    ...meta,
-                    _phaseState: ps,
-                    _error: {
-                        step: phase,
-                        code: 'ABORT',
-                        message: 'Aborted by operator',
-                    },
-                };
-                const lockPath = join(metaDir, '.lock');
-                const metaJsonPath = join(metaDir, 'meta.json');
-                await writeFile(lockPath, JSON.stringify(updated, null, 2) + '\n');
-                await copyFile(lockPath, metaJsonPath);
-            }
-            catch {
-                // Best-effort — meta may be unreadable
-            }
+        try {
+            const meta = await readMetaJson(metaDir);
+            let ps = derivePhaseState(meta);
+            ps = phaseFailed(ps, phase);
+            const updated = {
+                ...meta,
+                _phaseState: ps,
+                _error: {
+                    step: phase,
+                    code: 'ABORT',
+                    message: 'Aborted by operator',
+                },
+            };
+            const lockPath = join(metaDir, '.lock');
+            const metaJsonPath = join(metaDir, 'meta.json');
+            await writeFile(lockPath, JSON.stringify(updated, null, 2) + '\n');
+            await copyFile(lockPath, metaJsonPath);
+        }
+        catch {
+            // Best-effort — meta may be unreadable
         }
         // Release the lock for the current meta path
         try {
@@ -4906,11 +4831,11 @@ function registerQueueRoutes(app, deps) {
         catch {
             // Lock may already be released
         }
-        deps.logger.info({ path: current.path }, 'Synthesis aborted');
+        deps.logger.info({ path: currentPhase.path }, 'Synthesis aborted');
         return {
             status: 'aborted',
-            path: current.path,
-            ...(phase ? { phase } : {}),
+            path: currentPhase.path,
+            phase,
         };
     });
 }
@@ -4993,9 +4918,9 @@ async function checkWatcher(url) {
 function deriveServiceState(deps) {
     if (deps.shuttingDown)
         return 'stopping';
-    if (deps.queue.current || deps.queue.currentPhase)
+    if (deps.queue.currentPhase)
         return 'synthesizing';
-    if (deps.queue.depth > 0 || deps.queue.overrides.length > 0)
+    if (deps.queue.depth > 0)
         return 'waiting';
     return 'idle';
 }
@@ -5047,7 +4972,7 @@ function registerStatusRoute(app, deps) {
             }
             return {
                 serviceState: deriveServiceState(deps),
-                currentTarget: queue.current?.path ?? queue.currentPhase?.path ?? null,
+                currentTarget: queue.currentPhase?.path ?? null,
                 queue: queue.getState(),
                 stats: {
                     totalSyntheses: stats.totalSyntheses,
@@ -5135,7 +5060,7 @@ function registerSynthesizeRoute(app, deps) {
                     alreadyQueued: false,
                 });
             }
-            const result = queue.enqueueOverride(targetPath);
+            const result = queue.enqueue(targetPath);
             return reply.code(202).send({
                 status: 'queued',
                 path: targetPath,
@@ -5166,8 +5091,9 @@ function registerSynthesizeRoute(app, deps) {
         const stalest = winner.node.metaPath;
         const enqueueResult = queue.enqueue(stalest);
         return reply.code(202).send({
-            status: 'accepted',
+            status: 'queued',
             path: stalest,
+            owedPhase: winner.owedPhase,
             queuePosition: enqueueResult.position,
             alreadyQueued: enqueueResult.alreadyQueued,
         });
@@ -5316,26 +5242,14 @@ function registerShutdownHandlers(deps) {
             deps.logger.info('Scheduler stopped');
         }
         // 2. Release lock for in-progress synthesis
-        const current = deps.queue.current;
-        if (current) {
-            try {
-                releaseLock(current.path);
-                deps.logger.info({ path: current.path }, 'Released lock for in-progress synthesis');
-            }
-            catch {
-                deps.logger.warn({ path: current.path }, 'Failed to release lock during shutdown');
-            }
-        }
-        // Release lock for in-progress override synthesis (only when it
-        // differs from the legacy current item to avoid double-release)
         const currentPhase = deps.queue.currentPhase;
-        if (currentPhase && currentPhase.path !== current?.path) {
+        if (currentPhase) {
             try {
                 releaseLock(resolveMetaDir(currentPhase.path));
-                deps.logger.info({ path: currentPhase.path }, 'Released lock for in-progress override synthesis');
+                deps.logger.info({ path: currentPhase.path }, 'Released lock for in-progress synthesis');
             }
             catch {
-                deps.logger.warn({ path: currentPhase.path }, 'Failed to release override lock during shutdown');
+                deps.logger.warn({ path: currentPhase.path }, 'Failed to release lock during shutdown');
             }
         }
         // 3. Close server
@@ -5817,12 +5731,6 @@ const metaJsonSchema = z
     _error: metaErrorSchema.optional(),
     /** When true, this meta is skipped during staleness scheduling. Manual trigger still works. */
     _disabled: z.boolean().optional(),
-    /** Per-entity timeout override for the architect phase (seconds, min 30). */
-    _architectTimeout: z.number().int().min(30).optional(),
-    /** Per-entity timeout override for the builder phase (seconds, min 30). */
-    _builderTimeout: z.number().int().min(30).optional(),
-    /** Per-entity timeout override for the critic phase (seconds, min 30). */
-    _criticTimeout: z.number().int().min(30).optional(),
     /**
      * SHA-256 hash of ancestor _builder text at last synthesis.
      * Observability only — no invalidation cascade.