@pellux/goodvibes-sdk 0.25.7 → 0.25.8

package/dist/_internal/platform/channels/reply-pipeline.d.ts

@@ -6,6 +6,8 @@ export interface TrackedChannelReply {
     readonly agentId: string;
     readonly surfaceKind: ChannelSurface;
     readonly task: string;
+    readonly agentTask?: string;
+    readonly workflowChainId?: string;
     readonly createdAt: number;
     readonly sessionId?: string;
     readonly routeId?: string;
@@ -23,6 +25,7 @@ export declare class ChannelReplyPipeline {
     private readonly routeBindings;
     private readonly now;
     private readonly buffers;
+    private readonly workflowChains;
     private readonly unsubscribers;
     constructor(deps: ReplyPipelineDeps);
     attachRuntimeBus(runtimeBus: RuntimeEventBus | null): void;
@@ -32,9 +35,14 @@ export declare class ChannelReplyPipeline {
     has(agentId: string): boolean;
     getPending(agentId: string): TrackedChannelReply | null;
     deliverProgress(agentId: string, explicitText?: string, force?: boolean): Promise<ChannelRenderResult | null>;
-    deliverFinal(agentId: string, explicitText: string): Promise<ChannelRenderResult | null>;
+    deliverFinal(agentId: string, explicitText: string, options?: {
+        readonly keepTracking?: boolean;
+    }): Promise<ChannelRenderResult | null>;
     private handleEnvelope;
+    private handleWorkflowEnvelope;
     private trackChildPendingReply;
+    private findPendingForWorkflowTask;
+    private associateWorkflowChain;
     private resolvePolicy;
     private dispatch;
     private disposeSubscriptions;

package/dist/_internal/platform/channels/reply-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reply-pipeline.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/channels/reply-pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AACzG,OAAO,KAAK,EACV,kBAAkB,EAIlB,mBAAmB,EAEnB,cAAc,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAK9D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC;AAED,UAAU,iBAAiB;IACzB,QAAQ,CAAC,cAAc,EAAE,qBAAqB,CAAC;IAC/C,QAAQ,CAAC,aAAa,EAAE,mBAAmB,CAAC;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AA+OD,wBAAgB,sCAAsC,CACpD,QAAQ,EAAE,oBAAoB,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC,GACvE,kBAAkB,EAAE,CAyFtB;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwB;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsB;IACpD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAyB;gBAE3C,IAAI,EAAE,iBAAiB;IAOnC,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,GAAG,IAAI;IAmB1D,OAAO,IAAI,IAAI;IAKf,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAOhD,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI9B,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI7B,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI;IAIjD,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,KAAK,UAAQ,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAe3G,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAwBhF,cAAc;IAsC5B,OAAO,CAAC,sBAAsB;YAmBhB,aAAa;YAIb,QAAQ;IAgCtB,OAAO,CAAC,oBAAoB;CAK7B"}
+{"version":3,"file":"reply-pipeline.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/channels/reply-pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,eAAe,EAAiB,MAAM,4BAA4B,CAAC;AACxH,OAAO,KAAK,EACV,kBAAkB,EAIlB,mBAAmB,EAEnB,cAAc,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAK9D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC;AAED,UAAU,iBAAiB;IACzB,QAAQ,CAAC,cAAc,EAAE,qBAAqB,CAAC;IAC/C,QAAQ,CAAC,aAAa,EAAE,mBAAmB,CAAC;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AA+PD,wBAAgB,sCAAsC,CACpD,QAAQ,EAAE,oBAAoB,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC,GACvE,kBAAkB,EAAE,CAqItB;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwB;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsB;IACpD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;IAC5D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAyB;gBAE3C,IAAI,EAAE,iBAAiB;IAOnC,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,GAAG,IAAI;IAoB1D,OAAO,IAAI,IAAI;IAMf,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAUhD,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAS9B,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI7B,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI;IAIjD,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,KAAK,UAAQ,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAe3G,YAAY,CAChB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE;QAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAO,GAChD,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;YA0BxB,cAAc;YAiDd,sBAAsB;IAsCpC,OAAO,CAAC,sBAAsB;IAmB9B,OAAO,CAAC,0BAA0B;IAgBlC,OAAO,CAAC,sBAAsB;YAahB,aAAa;YAIb,QAAQ;IAgCtB,OAAO,CAAC,oBAAoB;CAK7B"}

package/dist/_internal/platform/channels/reply-pipeline.js

@@ -194,7 +194,10 @@ function buildRenderedText(explicitText, events, policy, phase) {
     if (phase === 'final' && explicitText.trim().length > 0) {
         return trimText(explicitText, policy.maxChunkChars);
     }
-    const lines = events
+    const renderableEvents = policy.surface === 'ntfy'
+        ? events.filter((event) => event.kind !== 'assistant_text' && event.kind !== 'reasoning')
+        : events;
+    const lines = renderableEvents
         .slice(-policy.maxEventsPerUpdate)
         .map((event) => eventLine(event, policy.reasoningVisibility))
         .filter((line) => Boolean(line && line.trim().length > 0));
@@ -217,6 +220,16 @@ function resolveEnvelopeAgentId(envelope) {
     const payload = envelope.payload;
     return typeof payload.agentId === 'string' ? payload.agentId : null;
 }
+function isWorkflowEventPayload(payload) {
+    return payload.type.startsWith('WORKFLOW_');
+}
+function resolveEnvelopeWorkflowChainId(envelope) {
+    const payload = envelope.payload;
+    return typeof payload.chainId === 'string' && payload.chainId.length > 0 ? payload.chainId : null;
+}
+function isAgentFinalEvent(type) {
+    return type === 'AGENT_COMPLETED' || type === 'AGENT_FAILED' || type === 'AGENT_CANCELLED';
+}
 export function normalizeChannelRenderEventFromRuntime(envelope) {
     const payload = envelope.payload;
     switch (payload.type) {
@@ -297,6 +310,50 @@ export function normalizeChannelRenderEventFromRuntime(envelope) {
             return [renderEvent(payload.type === 'COMPACTION_FAILED' ? 'error' : 'compaction', 'progress', envelope, {
                     text: payload.type.replace(/^COMPACTION_/, '').toLowerCase().replace(/_/g, ' '),
                 })];
+        case 'WORKFLOW_CHAIN_CREATED':
+            return [renderEvent('status', 'progress', envelope, {
+                    text: `WRFC chain ${payload.chainId.slice(0, 12)} started: ${trimText(payload.task, 180)}`,
+                })];
+        case 'WORKFLOW_STATE_CHANGED':
+            return [renderEvent('status', 'progress', envelope, {
+                    text: `WRFC chain ${payload.chainId.slice(0, 12)} moved from ${payload.from} to ${payload.to}`,
+                })];
+        case 'WORKFLOW_REVIEW_COMPLETED': {
+            const constraintSummary = typeof payload.constraintsSatisfied === 'number' && typeof payload.constraintsTotal === 'number'
+                ? `, constraints ${payload.constraintsSatisfied}/${payload.constraintsTotal}`
+                : '';
+            return [renderEvent(payload.passed ? 'status' : 'error', 'progress', envelope, {
+                    text: `WRFC review ${payload.passed ? 'passed' : 'needs fixes'}: score ${payload.score}/10${constraintSummary}`,
+                })];
+        }
+        case 'WORKFLOW_FIX_ATTEMPTED':
+            return [renderEvent('status', 'progress', envelope, {
+                    text: `WRFC fix attempt ${payload.attempt}/${payload.maxAttempts} started`,
+                })];
+        case 'WORKFLOW_GATE_RESULT':
+            return [renderEvent(payload.passed ? 'status' : 'error', 'progress', envelope, {
+                    text: `WRFC gate ${payload.gate} ${payload.passed ? 'passed' : 'failed'}`,
+                })];
+        case 'WORKFLOW_AUTO_COMMITTED':
+            return [renderEvent('status', 'progress', envelope, {
+                    text: `WRFC changes committed${payload.commitHash ? `: ${payload.commitHash}` : ''}`,
+                })];
+        case 'WORKFLOW_CASCADE_ABORTED':
+            return [renderEvent('error', 'progress', envelope, {
+                    text: `WRFC cascade warning: ${payload.reason}`,
+                })];
+        case 'WORKFLOW_CONSTRAINTS_ENUMERATED':
+            return [renderEvent('status', 'progress', envelope, {
+                    text: `WRFC constraints enumerated: ${payload.constraints.length}`,
+                })];
+        case 'WORKFLOW_CHAIN_PASSED':
+            return [renderEvent('status', 'final', envelope, {
+                    text: `WRFC chain ${payload.chainId.slice(0, 12)} passed`,
+                })];
+        case 'WORKFLOW_CHAIN_FAILED':
+            return [renderEvent('error', 'final', envelope, {
+                    text: `WRFC chain ${payload.chainId.slice(0, 12)} failed: ${payload.reason}`,
+                })];
         case 'TURN_COMPLETED':
             return payload.response.trim().length > 0
                 ? [renderEvent('assistant_text', 'final', envelope, { text: payload.response })]
@@ -312,6 +369,7 @@ export class ChannelReplyPipeline {
     routeBindings;
     now;
     buffers = new Map();
+    workflowChains = new Map();
     unsubscribers = [];
     constructor(deps) {
         this.channelPlugins = deps.channelPlugins;
@@ -331,6 +389,7 @@ export class ChannelReplyPipeline {
             'permissions',
             'providers',
             'compaction',
+            'workflows',
         ];
         for (const domain of domains) {
             this.unsubscribers.push(runtimeBus.onDomain(domain, (envelope) => {
@@ -341,15 +400,24 @@ export class ChannelReplyPipeline {
     dispose() {
         this.disposeSubscriptions();
         this.buffers.clear();
+        this.workflowChains.clear();
     }
     trackPending(pending) {
         this.buffers.set(pending.agentId, {
             pending,
             events: [],
         });
+        if (typeof pending.workflowChainId === 'string' && pending.workflowChainId.length > 0) {
+            this.workflowChains.set(pending.workflowChainId, pending.agentId);
+        }
     }
     untrack(agentId) {
         this.buffers.delete(agentId);
+        for (const [chainId, mappedAgentId] of this.workflowChains.entries()) {
+            if (mappedAgentId === agentId) {
+                this.workflowChains.delete(chainId);
+            }
+        }
     }
     has(agentId) {
         return this.buffers.has(agentId);
@@ -362,7 +430,7 @@ export class ChannelReplyPipeline {
         if (!state)
             return null;
         const policy = await this.resolvePolicy(state.pending.surfaceKind);
-        const text = buildRenderedText(explicitText ?? '', state.events, policy, 'progress');
+        const text = buildRenderedText(policy.surface === 'ntfy' ? '' : explicitText ?? '', state.events, policy, 'progress');
         if (!text)
             return null;
         if (!force && state.lastDeliveredText === text && (this.now() - (state.lastDeliveredAt ?? 0)) < DEFAULT_PROGRESS_INTERVAL_MS) {
@@ -373,7 +441,7 @@ export class ChannelReplyPipeline {
         state.lastDeliveredAt = this.now();
         return result;
     }
-    async deliverFinal(agentId, explicitText) {
+    async deliverFinal(agentId, explicitText, options = {}) {
         const state = this.buffers.get(agentId);
         if (!state)
             return null;
@@ -388,10 +456,16 @@ export class ChannelReplyPipeline {
             metadata: {},
         };
         const result = await this.dispatch(state, policy, 'final', buildRenderedText(explicitText, finalEvents.length > 0 ? finalEvents : [...state.events, statusEvent], policy, 'final'), finalEvents.length > 0 ? finalEvents : [...state.events.slice(-policy.maxEventsPerUpdate + 1), statusEvent]);
-        this.untrack(agentId);
+        if (!options.keepTracking) {
+            this.untrack(agentId);
+        }
         return result;
     }
     async handleEnvelope(envelope) {
+        if (isWorkflowEventPayload(envelope.payload)) {
+            await this.handleWorkflowEnvelope(envelope);
+            return;
+        }
         if (envelope.payload.type === 'AGENT_SPAWNING'
             && typeof envelope.payload.parentAgentId === 'string'
             && envelope.payload.parentAgentId.length > 0) {
@@ -412,17 +486,62 @@ export class ChannelReplyPipeline {
         }
         const hasFinal = events.some((event) => event.phase === 'final');
         if (hasFinal) {
+            const finalKinds = state.pending.surfaceKind === 'ntfy'
+                ? new Set(['error', 'status'])
+                : new Set(['assistant_text', 'error', 'status']);
             const text = events
-                .filter((event) => event.kind === 'assistant_text' || event.kind === 'error' || event.kind === 'status')
+                .filter((event) => finalKinds.has(event.kind))
                 .map((event) => event.text ?? '')
                 .filter(Boolean)
                 .join('\n')
                 .trim();
-            await this.deliverFinal(agentId, text);
+            await this.deliverFinal(agentId, text, {
+                keepTracking: state.pending.surfaceKind === 'ntfy'
+                    && typeof state.pending.workflowChainId === 'string'
+                    && isAgentFinalEvent(envelope.payload.type),
+            });
             return;
         }
         await this.deliverProgress(agentId);
     }
+    async handleWorkflowEnvelope(envelope) {
+        if (envelope.payload.type === 'WORKFLOW_CHAIN_CREATED') {
+            const matched = this.findPendingForWorkflowTask(envelope.payload.task);
+            if (matched) {
+                this.associateWorkflowChain(matched.pending.agentId, envelope.payload.chainId);
+            }
+        }
+        const chainId = resolveEnvelopeWorkflowChainId(envelope);
+        if (!chainId)
+            return;
+        const agentId = this.workflowChains.get(chainId);
+        if (!agentId)
+            return;
+        const state = this.buffers.get(agentId);
+        if (!state) {
+            this.workflowChains.delete(chainId);
+            return;
+        }
+        const events = normalizeChannelRenderEventFromRuntime(envelope);
+        if (events.length === 0)
+            return;
+        state.events.push(...events);
+        if (state.events.length > MAX_BUFFERED_EVENTS) {
+            state.events.splice(0, state.events.length - MAX_BUFFERED_EVENTS);
+        }
+        const hasFinal = events.some((event) => event.phase === 'final');
+        if (hasFinal) {
+            const text = events
+                .filter((event) => event.kind === 'error' || event.kind === 'status')
+                .map((event) => event.text ?? '')
+                .filter(Boolean)
+                .join('\n')
+                .trim();
+            await this.deliverFinal(agentId, text);
+            return;
+        }
+        await this.deliverProgress(agentId, undefined, true);
+    }
     trackChildPendingReply(agentId, parentAgentId, task) {
         if (this.buffers.has(agentId))
             return;
@@ -443,6 +562,37 @@ export class ChannelReplyPipeline {
             events: [],
         });
     }
+    findPendingForWorkflowTask(task) {
+        const normalizedTask = task.trim();
+        if (!normalizedTask)
+            return null;
+        let fallback = null;
+        for (const state of this.buffers.values()) {
+            if (typeof state.pending.workflowChainId === 'string')
+                continue;
+            const agentTask = typeof state.pending.agentTask === 'string' ? state.pending.agentTask.trim() : '';
+            const pendingTask = state.pending.task.trim();
+            if (agentTask === normalizedTask)
+                return state;
+            if (!fallback && pendingTask === normalizedTask) {
+                fallback = state;
+            }
+        }
+        return fallback;
+    }
+    associateWorkflowChain(agentId, chainId) {
+        const state = this.buffers.get(agentId);
+        if (!state)
+            return;
+        this.workflowChains.set(chainId, agentId);
+        this.buffers.set(agentId, {
+            ...state,
+            pending: {
+                ...state.pending,
+                workflowChainId: chainId,
+            },
+        });
+    }
     async resolvePolicy(surface) {
         return await this.channelPlugins.getRenderPolicy(surface) ?? DEFAULT_POLICY[surface];
     }

package/dist/_internal/platform/config/schema-domain-core.d.ts

@@ -75,6 +75,12 @@ export declare const coreConfigDefaults: {
         operationalMessages: string;
         wrfcMessages: string;
     };
+    tts: {
+        provider: string;
+        voice: string;
+        llmProvider: string;
+        llmModel: string;
+    };
     release: {
         channel: string;
     };

package/dist/_internal/platform/config/schema-domain-core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-domain-core.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/config/schema-domain-core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoH9B,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,uBAAuB,EAmX3D,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,uBAAuB,EA+H3D,CAAC"}
+{"version":3,"file":"schema-domain-core.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/config/schema-domain-core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0H9B,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,uBAAuB,EA2Y3D,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,uBAAuB,EA+H3D,CAAC"}

package/dist/_internal/platform/config/schema-domain-core.js

@@ -74,6 +74,12 @@ export const coreConfigDefaults = {
         operationalMessages: 'panel',
         wrfcMessages: 'both',
     },
+    tts: {
+        provider: 'elevenlabs',
+        voice: '',
+        llmProvider: '',
+        llmModel: '',
+    },
     release: {
         channel: 'stable',
     },
@@ -465,6 +471,30 @@ export const coreHeadConfigSettings = [
         description: 'Where operational system messages render by default: panel, conversation, or both',
         enumValues: ['panel', 'conversation', 'both'],
     },
+    {
+        key: 'tts.provider',
+        type: 'string',
+        default: 'elevenlabs',
+        description: 'Default TTS provider used by spoken-output clients when no provider is supplied on the request',
+    },
+    {
+        key: 'tts.voice',
+        type: 'string',
+        default: '',
+        description: 'Default TTS voice id used by spoken-output clients when no voice is supplied on the request',
+    },
+    {
+        key: 'tts.llmProvider',
+        type: 'string',
+        default: '',
+        description: 'Optional LLM provider override for spoken-output turns; empty means use the active chat provider',
+    },
+    {
+        key: 'tts.llmModel',
+        type: 'string',
+        default: '',
+        description: 'Optional LLM model override for spoken-output turns; empty means use the active chat model',
+    },
     {
         key: 'ui.operationalMessages',
         type: 'enum',

package/dist/_internal/platform/config/schema-domain-runtime.d.ts

@@ -8,6 +8,25 @@ export declare const runtimeConfigDefaults: {
             maxListeners: number;
         };
     };
+    batch: {
+        mode: string;
+        fallback: string;
+        queueBackend: string;
+        tickIntervalMs: number;
+        maxDelayMs: number;
+        maxJobsPerProviderBatch: number;
+        maxQueuePayloadBytes: number;
+        maxQueueMessagesPerDay: number;
+    };
+    cloudflare: {
+        enabled: boolean;
+        freeTierMode: boolean;
+        workerBaseUrl: string;
+        workerTokenRef: string;
+        queueName: string;
+        deadLetterQueueName: string;
+        maxQueueOpsPerDay: number;
+    };
     telemetry: {
         includeRawPrompts: boolean;
     };

package/dist/_internal/platform/config/schema-domain-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-domain-runtime.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/config/schema-domain-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFjC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,uBAAuB,EAyMjE,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,uBAAuB,EA2HnE,CAAC"}
+{"version":3,"file":"schema-domain-runtime.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/config/schema-domain-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmGjC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,uBAAuB,EAyMjE,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,uBAAuB,EA8NnE,CAAC"}

package/dist/_internal/platform/config/schema-domain-runtime.js

@@ -7,6 +7,25 @@ export const runtimeConfigDefaults = {
             maxListeners: 100,
         },
     },
+    batch: {
+        mode: 'off',
+        fallback: 'live',
+        queueBackend: 'local',
+        tickIntervalMs: 60_000,
+        maxDelayMs: 5 * 60 * 1000,
+        maxJobsPerProviderBatch: 100,
+        maxQueuePayloadBytes: 16 * 1024,
+        maxQueueMessagesPerDay: 1_000,
+    },
+    cloudflare: {
+        enabled: false,
+        freeTierMode: true,
+        workerBaseUrl: '',
+        workerTokenRef: '',
+        queueName: 'goodvibes-batch',
+        deadLetterQueueName: 'goodvibes-batch-dlq',
+        maxQueueOpsPerDay: 10_000,
+    },
     telemetry: {
         includeRawPrompts: false,
     },
@@ -401,4 +420,103 @@ export const runtimeSecondaryConfigSettings = [
             'Set to true ONLY for debugging in non-production environments — raw prompts may contain PII, secrets, or proprietary data. ' +
             'When true at startup, a WARN log is emitted to make the configuration visible to ops.',
     },
+    {
+        key: 'batch.mode',
+        type: 'enum',
+        default: 'off',
+        description: 'Daemon provider Batch API mode: off, explicit per request, or eligible-by-default for batch-capable daemon requests',
+        enumValues: ['off', 'explicit', 'eligible-by-default'],
+    },
+    {
+        key: 'batch.fallback',
+        type: 'enum',
+        default: 'live',
+        description: 'Fallback behavior when a batch-requested job is not eligible: live allows callers to choose live execution, fail rejects the batch job',
+        enumValues: ['live', 'fail'],
+    },
+    {
+        key: 'batch.queueBackend',
+        type: 'enum',
+        default: 'local',
+        description: 'Queue backend for daemon batch signals. local stores jobs under the daemon config directory; cloudflare requires cloudflare.enabled.',
+        enumValues: ['local', 'cloudflare'],
+    },
+    {
+        key: 'batch.tickIntervalMs',
+        type: 'number',
+        default: 60_000,
+        description: 'Daemon-local batch scheduler tick interval in milliseconds',
+        validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 5_000 && v <= 60 * 60 * 1000,
+    },
+    {
+        key: 'batch.maxDelayMs',
+        type: 'number',
+        default: 5 * 60 * 1000,
+        description: 'Maximum time a queued local batch job should wait before the daemon submits its provider batch',
+        validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0 && v <= 24 * 60 * 60 * 1000,
+    },
+    {
+        key: 'batch.maxJobsPerProviderBatch',
+        type: 'number',
+        default: 100,
+        description: 'Maximum SDK jobs grouped into a single upstream provider batch submission',
+        validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 1 && v <= 100_000,
+    },
+    {
+        key: 'batch.maxQueuePayloadBytes',
+        type: 'number',
+        default: 16 * 1024,
+        description: 'Recommended maximum Cloudflare queue message payload size; queue messages should be signals, not full prompt archives',
+        validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 1024 && v <= 128 * 1024,
+    },
+    {
+        key: 'batch.maxQueueMessagesPerDay',
+        type: 'number',
+        default: 1_000,
+        description: 'SDK-side free-tier guardrail for Cloudflare queue message volume',
+        validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0 && v <= 10_000_000,
+    },
+    {
+        key: 'cloudflare.enabled',
+        type: 'boolean',
+        default: false,
+        description: 'Enable optional Cloudflare Worker/Queue integration points. The daemon does not require Cloudflare when this is false.',
+    },
+    {
+        key: 'cloudflare.freeTierMode',
+        type: 'boolean',
+        default: true,
+        description: 'Prefer Cloudflare usage patterns that fit the free tier: small queue signals, local daemon storage, and bounded daily queue volume',
+    },
+    {
+        key: 'cloudflare.workerBaseUrl',
+        type: 'string',
+        default: '',
+        description: 'Optional deployed GoodVibes Cloudflare Worker base URL used by clients that proxy batch signals through Workers',
+    },
+    {
+        key: 'cloudflare.workerTokenRef',
+        type: 'string',
+        default: '',
+        description: 'Optional GoodVibes secret reference for the Worker-to-daemon bearer token',
+    },
+    {
+        key: 'cloudflare.queueName',
+        type: 'string',
+        default: 'goodvibes-batch',
+        description: 'Cloudflare Queue binding/name for GoodVibes batch job signals',
+    },
+    {
+        key: 'cloudflare.deadLetterQueueName',
+        type: 'string',
+        default: 'goodvibes-batch-dlq',
+        description: 'Cloudflare dead-letter queue binding/name for failed GoodVibes batch job signals',
+    },
+    {
+        key: 'cloudflare.maxQueueOpsPerDay',
+        type: 'number',
+        default: 10_000,
+        description: 'Free-tier queue operation budget used by clients to warn before Cloudflare queue usage exceeds the intended budget',
+        validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0 && v <= 10_000_000,
+    },
 ];