@jsonstudio/llms 0.6.954 → 0.6.1164

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.js

@@ -1,8 +1,14 @@
 import { chatEnvelopeToStandardized } from '../../../../standardized-bridge.js';
 import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
+import { applyHubOperationTableInbound } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
 export async function runReqInboundStage2SemanticMap(options) {
     const chatEnvelope = await options.semanticMapper.toChat(options.formatEnvelope, options.adapterContext);
+    applyHubOperationTableInbound({
+        formatEnvelope: options.formatEnvelope,
+        chatEnvelope,
+        adapterContext: options.adapterContext
+    });
     validateChatEnvelope(chatEnvelope, {
         stage: 'req_inbound',
         direction: 'request'

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.js

@@ -1,5 +1,6 @@
 import { standardizedToChatEnvelope } from '../../../../standardized-bridge.js';
 import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
+import { applyHubOperationTableOutboundPostMap, applyHubOperationTableOutboundPreMap } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
 export async function runReqOutboundStage1SemanticMap(options) {
     const chatEnvelope = standardizedToChatEnvelope(options.request, {
@@ -16,7 +17,17 @@ export async function runReqOutboundStage1SemanticMap(options) {
         stage: 'req_outbound',
         direction: 'request'
     });
+    await applyHubOperationTableOutboundPreMap({
+        protocol: options.adapterContext.providerProtocol,
+        chatEnvelope,
+        adapterContext: options.adapterContext
+    });
     const formatEnvelope = (await options.semanticMapper.fromChat(chatEnvelope, options.adapterContext));
+    applyHubOperationTableOutboundPostMap({
+        chatEnvelope,
+        formatEnvelope,
+        adapterContext: options.adapterContext
+    });
     recordStage(options.stageRecorder, 'req_outbound_stage1_semantic_map', chatEnvelope);
     return { chatEnvelope, formatEnvelope };
 }

package/dist/conversion/hub/policy/policy-engine.js

@@ -38,6 +38,11 @@ function applyProviderOutboundPolicy(providerProtocol, payload) {
             out = { ...payload };
         }
     };
+    const allowedTopLevelKeys = Array.isArray(spec.providerOutbound.allowedTopLevelKeys) &&
+        spec.providerOutbound.allowedTopLevelKeys.length > 0 &&
+        spec.providerOutbound.enforceAllowedTopLevelKeys === true
+        ? new Set(spec.providerOutbound.allowedTopLevelKeys)
+        : undefined;
     // Reserved/private keys must never be sent upstream.
     for (const key of Object.keys(payload)) {
         if (spec.providerOutbound.reservedKeyPrefixes.some((prefix) => key.startsWith(prefix))) {
@@ -76,6 +81,18 @@ function applyProviderOutboundPolicy(providerProtocol, payload) {
         delete out[wrapperKey];
         flattenedWrappers.push(wrapperKey);
     }
+    // Enforce protocol allowlist (top-level). Only runs when explicitly enabled
+    // for this protocol, and only after wrapper flatten so allowed fields are
+    // present at the correct level.
+    if (allowedTopLevelKeys) {
+        for (const key of Object.keys(out)) {
+            if (allowedTopLevelKeys.has(key))
+                continue;
+            ensureOutClone();
+            delete out[key];
+            removedTopLevelKeys.push(key);
+        }
+    }
     return {
         payload: out,
         changed: out !== payload || removedTopLevelKeys.length > 0 || flattenedWrappers.length > 0,
@@ -83,16 +100,20 @@ function applyProviderOutboundPolicy(providerProtocol, payload) {
         flattenedWrappers
     };
 }
-function observeProviderOutboundPayload(providerProtocol, payload) {
+function observeProviderPayload(options) {
     const violations = [];
-    // V0 (observe-only): detect known "layout anti-patterns" and reserved keys.
+    // Observe-only: detect known layout anti-patterns and reserved keys.
     // Do NOT modify payload here.
-    const spec = resolveHubProtocolSpec(providerProtocol);
+    const spec = resolveHubProtocolSpec(options.providerProtocol);
+    const allowlistEnabled = options.phase === 'provider_outbound';
+    const allowedTopLevelKeys = allowlistEnabled && Array.isArray(spec.providerOutbound.allowedTopLevelKeys)
+        ? new Set(spec.providerOutbound.allowedTopLevelKeys)
+        : undefined;
     for (const rule of spec.providerOutbound.forbidWrappers) {
         if (rule.code !== 'forbid_wrapper') {
             continue;
         }
-        if (rule.path in payload && isJsonRecord(payload[rule.path])) {
+        if (rule.path in options.payload && isJsonRecord(options.payload[rule.path])) {
             violations.push({
                 code: 'unexpected_wrapper',
                 path: rule.path,
@@ -101,18 +122,26 @@ function observeProviderOutboundPayload(providerProtocol, payload) {
         }
     }
     // Always record unknown private wrapper keys (best-effort, conservative).
-    for (const key of Object.keys(payload)) {
+    for (const key of Object.keys(options.payload)) {
         if (spec.providerOutbound.reservedKeyPrefixes.some((prefix) => key.startsWith(prefix))) {
             violations.push({
                 code: 'unexpected_field',
                 path: key
             });
+            continue;
+        }
+        if (allowedTopLevelKeys && !allowedTopLevelKeys.has(key)) {
+            violations.push({
+                code: 'unexpected_field',
+                path: key,
+                detail: `Top-level key is not in protocol allowlist: ${options.providerProtocol}`
+            });
         }
     }
     const unexpectedFieldCount = violations.filter((v) => v.code === 'unexpected_field').length;
     return {
-        phase: 'provider_outbound',
-        providerProtocol,
+        phase: options.phase,
+        providerProtocol: options.providerProtocol,
         violations,
         summary: {
             totalViolations: violations.length,
@@ -136,8 +165,11 @@ export function recordHubPolicyObservation(options) {
     }
     try {
         const phase = options.phase ?? 'provider_outbound';
-        const observation = observeProviderOutboundPayload(options.providerProtocol, options.payload);
-        observation.phase = phase;
+        const observation = observeProviderPayload({
+            phase,
+            providerProtocol: options.providerProtocol,
+            payload: options.payload
+        });
         if (observation.summary.totalViolations <= 0) {
             return;
         }

package/dist/conversion/hub/policy/protocol-spec.d.ts

@@ -26,6 +26,19 @@ export interface ProviderOutboundPolicySpec {
      * Keep this false for protocols not yet migrated, to avoid behavior changes.
      */
     enforceEnabled: boolean;
+    /**
+     * Provider outbound payload allowlist (top-level keys), used for observation
+     * to detect drift.
+     */
+    allowedTopLevelKeys?: readonly string[];
+    /**
+     * When enabled, provider outbound payload will drop any top-level keys not
+     * present in allowedTopLevelKeys (after wrapper flatten).
+     *
+     * Keep this configurable for progressive rollout, but Phase 1 completion
+     * requires enabling it for all protocols.
+     */
+    enforceAllowedTopLevelKeys?: boolean;
     /**
      * Reserved/private key prefixes that must not be sent upstream.
      * (Enforced only when enforceEnabled=true.)
@@ -42,9 +55,21 @@ export interface ProviderOutboundPolicySpec {
      */
     flattenWrappers: ProviderOutboundWrapperFlattenRule[];
 }
+export type ToolDefinitionFormat = 'openai' | 'anthropic' | 'gemini';
+export type ProviderOutboundHistoryCarrier = 'messages' | 'input';
+export interface ToolSurfaceSpec {
+    expectedToolFormat: ToolDefinitionFormat;
+    /**
+     * For OpenAI protocols, tool call/result history may be carried in either
+     * chat `messages[]` or responses `input[]`. This spec describes the expected
+     * carrier so toolSurface can normalize or at least record diffs.
+     */
+    expectedHistoryCarrier?: ProviderOutboundHistoryCarrier;
+}
 export interface ProtocolSpec {
     id: HubProviderProtocol;
     providerOutbound: ProviderOutboundPolicySpec;
+    toolSurface: ToolSurfaceSpec;
 }
 export declare const HUB_PROTOCOL_SPECS: Record<HubProviderProtocol, ProtocolSpec>;
 export declare function resolveHubProtocolSpec(protocol: string): ProtocolSpec;

package/dist/conversion/hub/policy/protocol-spec.js

@@ -1,7 +1,10 @@
+import { ANTHROPIC_ALLOWED_FIELDS, ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS, GEMINI_ALLOWED_FIELDS, OPENAI_CHAT_ALLOWED_FIELDS, OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS, OPENAI_RESPONSES_ALLOWED_FIELDS, OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS } from '../../shared/protocol-field-allowlists.js';
 const RESPONSES_SPEC = {
     id: 'openai-responses',
     providerOutbound: {
         enforceEnabled: true,
+        allowedTopLevelKeys: OPENAI_RESPONSES_ALLOWED_FIELDS,
+        enforceAllowedTopLevelKeys: true,
         forbidWrappers: [
             {
                 code: 'forbid_wrapper',
@@ -26,30 +29,21 @@ const RESPONSES_SPEC = {
                 aliasKeys: {
                     max_tokens: 'max_output_tokens'
                 },
-                allowKeys: [
-                    'temperature',
-                    'top_p',
-                    'max_output_tokens',
-                    'seed',
-                    'logit_bias',
-                    'user',
-                    'parallel_tool_calls',
-                    'tool_choice',
-                    'response_format',
-                    'stream',
-                    'stop',
-                    'stop_sequences',
-                    'modalities',
-                    'top_k'
-                ]
+                allowKeys: [...OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS]
             }
         ]
+    },
+    toolSurface: {
+        expectedToolFormat: 'openai',
+        expectedHistoryCarrier: 'input'
     }
 };
 const DEFAULT_SPEC = {
     id: 'openai-chat',
     providerOutbound: {
-        enforceEnabled: false,
+        enforceEnabled: true,
+        allowedTopLevelKeys: OPENAI_CHAT_ALLOWED_FIELDS,
+        enforceAllowedTopLevelKeys: true,
         forbidWrappers: [
             {
                 code: 'forbid_wrapper',
@@ -63,7 +57,24 @@ const DEFAULT_SPEC = {
             }
         ],
         reservedKeyPrefixes: ['__', '_'],
-        flattenWrappers: []
+        flattenWrappers: [
+            {
+                wrapperKey: 'request',
+                onlyIfTargetMissing: true
+            },
+            {
+                wrapperKey: 'parameters',
+                onlyIfTargetMissing: true,
+                aliasKeys: {
+                    max_output_tokens: 'max_tokens'
+                },
+                allowKeys: [...OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS]
+            }
+        ]
+    },
+    toolSurface: {
+        expectedToolFormat: 'openai',
+        expectedHistoryCarrier: 'messages'
     }
 };
 export const HUB_PROTOCOL_SPECS = {
@@ -72,7 +83,9 @@ export const HUB_PROTOCOL_SPECS = {
     'anthropic-messages': {
         id: 'anthropic-messages',
         providerOutbound: {
-            enforceEnabled: false,
+            enforceEnabled: true,
+            allowedTopLevelKeys: ANTHROPIC_ALLOWED_FIELDS,
+            enforceAllowedTopLevelKeys: true,
             forbidWrappers: [
                 {
                     code: 'forbid_wrapper',
@@ -86,16 +99,53 @@ export const HUB_PROTOCOL_SPECS = {
                 }
             ],
             reservedKeyPrefixes: ['__', '_'],
-            flattenWrappers: []
+            flattenWrappers: [
+                {
+                    wrapperKey: 'request',
+                    onlyIfTargetMissing: true
+                },
+                {
+                    wrapperKey: 'parameters',
+                    onlyIfTargetMissing: true,
+                    aliasKeys: {
+                        max_output_tokens: 'max_tokens'
+                    },
+                    allowKeys: [...ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS]
+                }
+            ]
+        },
+        toolSurface: {
+            expectedToolFormat: 'anthropic'
         }
     },
     'gemini-chat': {
         id: 'gemini-chat',
         providerOutbound: {
-            enforceEnabled: false,
-            forbidWrappers: [],
+            enforceEnabled: true,
+            allowedTopLevelKeys: GEMINI_ALLOWED_FIELDS,
+            enforceAllowedTopLevelKeys: true,
+            forbidWrappers: [
+                {
+                    code: 'forbid_wrapper',
+                    path: 'parameters',
+                    detail: 'Gemini provider payload must not contain a top-level parameters wrapper.'
+                },
+                {
+                    code: 'forbid_wrapper',
+                    path: 'request',
+                    detail: 'Gemini provider payload must not contain a nested request wrapper.'
+                }
+            ],
             reservedKeyPrefixes: ['__', '_'],
-            flattenWrappers: []
+            flattenWrappers: [
+                {
+                    wrapperKey: 'request',
+                    onlyIfTargetMissing: true
+                }
+            ]
+        },
+        toolSurface: {
+            expectedToolFormat: 'gemini'
         }
     }
 };

package/dist/conversion/hub/process/chat-process.js

@@ -2,7 +2,9 @@ import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js'
 import { ToolGovernanceEngine } from '../tool-governance/index.js';
 import { ensureApplyPatchSchema } from '../../shared/tool-mapping.js';
 import { normalizeApplyPatchToolCallsOnRequest } from '../../shared/tool-governor.js';
+import { clearClockSession, normalizeClockConfig, reserveDueTasksForRequest, startClockDaemonIfNeeded } from '../../../servertool/clock/task-store.js';
 import { isJsonObject } from '../types/json.js';
+import { applyHubOperations } from '../ops/operations.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
     const startTime = Date.now();
@@ -90,28 +92,22 @@ async function applyRequestToolGovernance(request, context) {
         merged.metadata.hasImageAttachment = true;
     }
     if (typeof inboundStreamIntent === 'boolean') {
-        merged.metadata = {
-            ...merged.metadata,
-            inboundStream: inboundStreamIntent
-        };
+        merged = applyHubOperations(merged, buildInboundStreamingOperations(inboundStreamIntent));
     }
     if (typeof governed.stream === 'boolean') {
-        merged.parameters = {
-            ...merged.parameters,
-            stream: governed.stream
-        };
+        merged = applyHubOperations(merged, buildOutboundStreamingOperations(governed.stream));
     }
     if (governed.tool_choice !== undefined) {
-        merged.parameters = {
-            ...merged.parameters,
-            tool_choice: governed.tool_choice
-        };
+        merged = applyHubOperations(merged, buildToolChoiceOperations(governed.tool_choice));
     }
     if (typeof governed.model === 'string' && governed.model.trim()) {
         merged.model = governed.model.trim();
     }
     // Server-side web_search tool injection (config-driven, best-effort).
-    merged = maybeInjectWebSearchTool(merged, metadata);
+    merged = applyHubOperations(merged, buildWebSearchOperations(merged, metadata));
+    // Server-side clock tool + scheduled reminders injection (config-driven, best-effort).
+    merged = applyHubOperations(merged, buildClockOperations(metadata));
+    merged = await maybeInjectClockRemindersAndApplyDirectives(merged, metadata, context.requestId);
     const { request: sanitized, summary } = toolGovernanceEngine.governRequest(merged, providerProtocol);
     if (summary.applied) {
         sanitized.metadata = {
@@ -397,18 +393,49 @@ function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
 function maybeInjectWebSearchTool(request, metadata) {
+    const ops = buildWebSearchOperations(request, metadata);
+    if (!ops.length) {
+        return request;
+    }
+    return applyHubOperations(request, ops);
+}
+function buildInboundStreamingOperations(intent) {
+    return [
+        {
+            op: 'set_request_metadata_fields',
+            fields: { inboundStream: intent }
+        }
+    ];
+}
+function buildOutboundStreamingOperations(stream) {
+    return [
+        {
+            op: 'set_request_parameter_fields',
+            fields: { stream }
+        }
+    ];
+}
+function buildToolChoiceOperations(toolChoice) {
+    return [
+        {
+            op: 'set_request_parameter_fields',
+            fields: { tool_choice: toolChoice }
+        }
+    ];
+}
+function buildWebSearchOperations(request, metadata) {
     // ServerTool 二/三跳（serverToolFollowup=true）不再注入 web_search 工具，
     // 以避免在 web_search 流程内部形成循环命中。
     if (metadata.serverToolFollowup === true) {
-        return request;
+        return [];
     }
     const rawConfig = metadata.webSearch;
     if (!rawConfig || !Array.isArray(rawConfig.engines) || rawConfig.engines.length === 0) {
-        return request;
+        return [];
     }
     const semanticsWebSearch = extractWebSearchSemantics(request.semantics);
     if (semanticsWebSearch?.disable === true) {
-        return request;
+        return [];
     }
     const injectPolicy = semanticsWebSearch?.force === true
         ? 'always'
@@ -420,26 +447,10 @@ function maybeInjectWebSearchTool(request, metadata) {
         // 仅当当前这一轮用户输入明确表达“联网搜索”意图时才注入 web_search。
         // 不再依赖上一轮工具分类（read/search/websearch），避免形成隐式续写语义。
         if (!intent.hasIntent) {
-            return request;
+            return [];
         }
     }
     const existingTools = Array.isArray(request.tools) ? request.tools : [];
-    const hasWebSearch = existingTools.some((tool) => {
-        if (!tool || typeof tool !== 'object')
-            return false;
-        const fn = tool.function;
-        return typeof fn?.name === 'string' && fn.name.trim() === 'web_search';
-    });
-    if (hasWebSearch) {
-        const nextMetadata = {
-            ...(request.metadata ?? {}),
-            webSearchEnabled: true
-        };
-        return {
-            ...request,
-            metadata: nextMetadata
-        };
-    }
     let engines = rawConfig.engines.filter((engine) => typeof engine?.id === 'string' && !!engine.id.trim() && !engine.serverToolsDisabled);
     // 当用户明确要求「谷歌搜索」时，只暴露 Gemini / Antigravity 类搜索后端：
     // - providerKey 以 gemini-cli. 或 antigravity. 开头；
@@ -461,7 +472,7 @@ function maybeInjectWebSearchTool(request, metadata) {
         }
     }
     if (!engines.length) {
-        return request;
+        return [];
     }
     const engineIds = engines.map((engine) => engine.id.trim());
     const engineDescriptions = engines
@@ -511,15 +522,215 @@ function maybeInjectWebSearchTool(request, metadata) {
             strict: true
         }
     };
-    const nextMetadata = {
-        ...(request.metadata ?? {}),
-        webSearchEnabled: true
+    const ops = [
+        {
+            op: 'set_request_metadata_fields',
+            fields: { webSearchEnabled: true }
+        }
+    ];
+    ops.push({
+        op: 'append_tool_if_missing',
+        toolName: 'web_search',
+        tool: webSearchTool
+    });
+    return ops;
+}
+function buildClockOperations(metadata) {
+    const rawConfig = metadata.clock;
+    const clockConfig = normalizeClockConfig(rawConfig);
+    if (!clockConfig) {
+        return [];
+    }
+    const parameters = {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['schedule', 'list', 'cancel', 'clear'],
+                description: 'Schedule, list, cancel, or clear session-scoped reminders.'
+            },
+            items: {
+                type: 'array',
+                description: 'For schedule: list of reminders to add.',
+                items: {
+                    type: 'object',
+                    properties: {
+                        dueAt: {
+                            type: 'string',
+                            description: 'ISO8601 datetime with timezone (e.g. 2026-01-21T20:30:00-08:00).'
+                        },
+                        task: {
+                            type: 'string',
+                            description: 'Reminder text (should include which tool to use and what to do).'
+                        },
+                        tool: {
+                            type: 'string',
+                            description: 'Optional suggested tool name (hint only).'
+                        },
+                        arguments: {
+                            type: 'object',
+                            description: 'Optional suggested tool arguments (hint only).',
+                            additionalProperties: true
+                        }
+                    },
+                    required: ['dueAt', 'task'],
+                    additionalProperties: false
+                }
+            },
+            taskId: {
+                type: 'string',
+                description: 'For cancel: taskId to remove.'
+            }
+        },
+        required: ['action'],
+        additionalProperties: false
     };
-    return {
-        ...request,
-        metadata: nextMetadata,
-        tools: [...existingTools, webSearchTool]
+    const clockTool = {
+        type: 'function',
+        function: {
+            name: 'clock',
+            description: 'Schedule session-scoped reminders. Use schedule/list/cancel/clear. Scheduled reminders will be injected into future requests as [scheduled task:"..."].',
+            parameters,
+            strict: true
+        }
     };
+    return [
+        { op: 'set_request_metadata_fields', fields: { clockEnabled: true, serverToolRequired: true } },
+        { op: 'append_tool_if_missing', toolName: 'clock', tool: clockTool }
+    ];
+}
+function resolveSessionIdForClock(metadata, request) {
+    const candidate = readString(metadata.sessionId) ?? readString(request.metadata?.sessionId);
+    return candidate && candidate.trim() ? candidate.trim() : null;
+}
+function stripClockClearDirectiveFromText(text) {
+    const pattern = /<\*\*\s*clock\s*:\s*clear\s*\*\*>/gi;
+    const hadClear = pattern.test(text);
+    if (!hadClear) {
+        return { hadClear: false, next: text };
+    }
+    const replaced = text.replace(pattern, '');
+    // Clean up leftover excessive blank lines to keep prompts tidy.
+    const next = replaced.replace(/\n{3,}/g, '\n\n').trim();
+    return { hadClear: true, next };
+}
+function stripClockClearDirectiveFromContent(content) {
+    if (typeof content === 'string') {
+        const { hadClear, next } = stripClockClearDirectiveFromText(content);
+        return { hadClear, next };
+    }
+    if (Array.isArray(content)) {
+        let hadClear = false;
+        const next = content.map((part) => {
+            if (typeof part === 'string') {
+                const stripped = stripClockClearDirectiveFromText(part);
+                if (stripped.hadClear)
+                    hadClear = true;
+                return stripped.next;
+            }
+            if (part && typeof part === 'object' && !Array.isArray(part)) {
+                const block = part;
+                const text = typeof block.text === 'string' ? block.text : undefined;
+                if (!text)
+                    return part;
+                const stripped = stripClockClearDirectiveFromText(text);
+                if (stripped.hadClear)
+                    hadClear = true;
+                return { ...block, text: stripped.next };
+            }
+            return part;
+        });
+        return { hadClear, next };
+    }
+    return { hadClear: false, next: content };
+}
+function findLastUserMessageIndex(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return -1;
+    }
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const candidate = messages[idx];
+        if (candidate && candidate.role === 'user') {
+            return idx;
+        }
+    }
+    return -1;
+}
+async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, requestId) {
+    const rawConfig = metadata.clock;
+    const clockConfig = normalizeClockConfig(rawConfig);
+    if (!clockConfig) {
+        return request;
+    }
+    try {
+        await startClockDaemonIfNeeded(clockConfig);
+    }
+    catch {
+        // best-effort
+    }
+    const sessionId = resolveSessionIdForClock(metadata, request);
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    const lastUserIdx = findLastUserMessageIndex(messages);
+    // 1) Apply <**clock:clear**> directive (latest user message only).
+    let hadClear = false;
+    let nextMessages = messages;
+    if (lastUserIdx >= 0) {
+        const lastUser = messages[lastUserIdx];
+        const stripped = stripClockClearDirectiveFromContent(lastUser.content);
+        hadClear = stripped.hadClear;
+        if (hadClear) {
+            nextMessages = messages.slice();
+            nextMessages[lastUserIdx] = { ...lastUser, content: stripped.next };
+        }
+    }
+    if (hadClear) {
+        if (sessionId) {
+            try {
+                await clearClockSession(sessionId);
+            }
+            catch {
+                // best-effort: user directive should not crash request
+            }
+        }
+        return { ...request, messages: nextMessages };
+    }
+    // 2) Inject due reminders as a system message + attach reservation for response-side commit.
+    if (!sessionId) {
+        return request;
+    }
+    try {
+        const { reservation, injectText } = await reserveDueTasksForRequest({
+            reservationId: `${requestId}:clock`,
+            sessionId,
+            config: clockConfig
+        });
+        if (!reservation || typeof injectText !== 'string' || !injectText.trim()) {
+            return request;
+        }
+        const baseMetadata = request.metadata && typeof request.metadata === 'object'
+            ? request.metadata
+            : {
+                originalEndpoint: readString(metadata.originalEndpoint) ?? '/v1/chat/completions'
+            };
+        return {
+            ...request,
+            messages: [
+                ...messages,
+                {
+                    role: 'system',
+                    content: injectText.trim()
+                }
+            ],
+            metadata: {
+                ...baseMetadata,
+                __clockReservation: reservation
+            }
+        };
+    }
+    catch {
+        // best-effort: never break request due to reminder injection failures
+        return request;
+    }
 }
 function extractWebSearchSemantics(semantics) {
     if (!semantics || typeof semantics !== 'object') {