@jsonstudio/llms 0.6.1739 → 0.6.1890

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -19,6 +19,15 @@ export function runRespOutboundStage1ClientRemap(options) {
             requestId: options.requestId,
             ...(toolsRaw ? { toolsRaw } : {})
         });
+        if (options.payload && typeof options.payload === 'object' && !Array.isArray(options.payload)) {
+            const source = options.payload;
+            const passthrough = ['metadata', 'temperature', 'top_p', 'prompt_cache_key', 'reasoning'];
+            for (const key of passthrough) {
+                if (clientPayload[key] === undefined && source[key] !== undefined) {
+                    clientPayload[key] = jsonClone(source[key]);
+                }
+            }
+        }
     }
     // Preserve upstream error envelope when present (used by host status mapping + servertool auto flows).
     try {

package/dist/conversion/hub/policy/policy-engine.d.ts

@@ -33,6 +33,7 @@ export declare function recordHubPolicyObservation(options: {
     policy?: HubPolicyConfig;
     phase?: PolicyObservation['phase'];
     providerProtocol: string;
+    compatibilityProfile?: string;
     payload: JsonObject;
     stageRecorder?: StageRecorder;
     requestId?: string;
@@ -40,6 +41,7 @@ export declare function recordHubPolicyObservation(options: {
 export declare function applyHubProviderOutboundPolicy(options: {
     policy?: HubPolicyConfig;
     providerProtocol: string;
+    compatibilityProfile?: string;
     payload: JsonObject;
     stageRecorder?: StageRecorder;
     requestId?: string;

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

@@ -207,6 +207,10 @@ export function recordHubPolicyObservation(options) {
     if (mode !== 'observe' && mode !== 'enforce') {
         return;
     }
+    const compatibilityProfile = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
+    if (compatibilityProfile === 'chat:deepseek-web') {
+        return;
+    }
     if (!shouldSample(effectivePolicy?.sampleRate)) {
         return;
     }
@@ -236,6 +240,10 @@ export function applyHubProviderOutboundPolicy(options) {
     if (mode !== 'enforce') {
         return options.payload;
     }
+    const compatibilityProfile = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
+    if (compatibilityProfile === 'chat:deepseek-web') {
+        return options.payload;
+    }
     const result = applyProviderOutboundPolicy(options.providerProtocol, options.payload);
     if (!result.changed) {
         return options.payload;

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

@@ -4,13 +4,23 @@ import { readRuntimeMetadata } from '../../shared/runtime-metadata.js';
 import { ensureApplyPatchSchema } from '../../shared/tool-mapping.js';
 import { normalizeApplyPatchToolCallsOnRequest } from '../../shared/tool-governor.js';
 import { buildAnthropicToolAliasMap } from '../../shared/anthropic-message-utils.js';
-import { clearClockSession, resolveClockConfig, reserveDueTasksForRequest, startClockDaemonIfNeeded } from '../../../servertool/clock/task-store.js';
+import { clearClockSession, parseDueAtMs, resolveClockConfig, reserveDueTasksForRequest, scheduleClockTasks, startClockDaemonIfNeeded } from '../../../servertool/clock/task-store.js';
 import { logClock } from '../../../servertool/clock/log.js';
+import { logContinueExecution } from '../../../servertool/continue-execution/log.js';
 import { buildTimeTagLine, getClockTimeSnapshot } from '../../../servertool/clock/ntp.js';
 import { clearPendingServerToolInjection, loadPendingServerToolInjection } from '../../../servertool/pending-session.js';
+import { loadRoutingInstructionStateSync } from '../../../router/virtual-router/sticky-session-store.js';
 import { isJsonObject } from '../types/json.js';
 import { applyHubOperations } from '../ops/operations.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
+const CONTINUE_EXECUTION_SYSTEM_DIRECTIVE_MARKER = '[routecodex:continue_execution_directive]';
+const CONTINUE_EXECUTION_SYSTEM_DIRECTIVE = [
+    CONTINUE_EXECUTION_SYSTEM_DIRECTIVE_MARKER,
+    'Execution policy (must follow):',
+    '- Do not output status-talk placeholders such as \"继续执行中\" / \"I will continue\" before real work.',
+    '- Perform at least one real action first (prefer tool calls), then report concise results when needed.',
+    '- If you are about to return finish_reason=stop (or protocol-equivalent end_turn), do not end directly; emit a continue_execution tool call first.'
+].join('\n');
 export async function runHubChatProcess(options) {
     const startTime = Date.now();
     try {
@@ -144,6 +154,9 @@ async function applyRequestToolGovernance(request, context) {
     merged = applyHubOperations(merged, buildWebSearchOperations(merged, metadata));
     // Server-side clock tool + scheduled reminders injection (config-driven, best-effort).
     merged = applyHubOperations(merged, buildClockOperations(metadata));
+    // Server-side no-op continue tool injection (always-on, lightweight).
+    merged = applyHubOperations(merged, buildContinueExecutionOperations(metadata));
+    merged = injectContinueExecutionDirectiveIntoUserMessage(merged, metadata);
     merged = await maybeInjectClockRemindersAndApplyDirectives(merged, metadata, context.requestId);
     const { request: sanitized, summary } = toolGovernanceEngine.governRequest(merged, providerProtocol);
     if (summary.applied) {
@@ -646,7 +659,8 @@ function buildWebSearchOperations(request, metadata) {
 function buildClockOperations(metadata) {
     const rt = readRuntimeMetadata(metadata);
     // Do not inject clock tool into internal servertool followup hops.
-    if (rt?.serverToolFollowup === true) {
+    const allowClockFollowupToolInjection = rt?.clockFollowupInjectTool === true;
+    if (rt?.serverToolFollowup === true && !allowClockFollowupToolInjection) {
         return [];
     }
     const rawConfig = rt?.clock;
@@ -662,12 +676,12 @@ function buildClockOperations(metadata) {
         properties: {
             action: {
                 type: 'string',
-                enum: ['get', 'schedule', 'list', 'cancel', 'clear'],
-                description: 'Get current time, or schedule/list/cancel/clear session-scoped reminders.'
+                enum: ['get', 'schedule', 'update', 'list', 'cancel', 'clear'],
+                description: 'Get current time, or schedule/update/list/cancel/clear session-scoped reminders. For any wait/later requirement, schedule immediately.'
             },
             items: {
                 type: 'array',
-                description: 'For schedule: list of reminders to add.',
+                description: 'For schedule/update: list of reminder payloads. update uses items[0] as patch source.',
                 items: {
                     type: 'object',
                     properties: {
@@ -677,7 +691,7 @@ function buildClockOperations(metadata) {
                         },
                         task: {
                             type: 'string',
-                            description: 'Reminder text (should include which tool to use and what to do).'
+                            description: 'Reminder text that states the exact action to execute on wake-up (no vague placeholders).'
                         },
                         tool: {
                             type: 'string',
@@ -696,7 +710,7 @@ function buildClockOperations(metadata) {
             },
             taskId: {
                 type: 'string',
-                description: 'For cancel: taskId to remove.'
+                description: 'For cancel/update: target taskId.'
             }
         },
         // For strict tool schemas (OpenAI Responses), required must include every key in properties.
@@ -708,7 +722,7 @@ function buildClockOperations(metadata) {
         type: 'function',
         function: {
             name: 'clock',
-            description: 'Time + Alarm for this session. Use get/schedule/list/cancel/clear. Scheduled reminders will be injected into future requests.',
+            description: 'Time + Alarm for this session. MUST use clock.schedule whenever waiting/delay is required. Never promise to wait without scheduling. Use get/schedule/update/list/cancel/clear. Scheduled reminders are injected into future requests.',
             parameters,
             strict: true
         }
@@ -721,6 +735,175 @@ function buildClockOperations(metadata) {
         { op: 'append_tool_if_missing', toolName: 'clock', tool: clockTool }
     ];
 }
+function hasActiveStopMessageStateForContinueExecution(metadata) {
+    const rt = readRuntimeMetadata(metadata);
+    if (isStopMessageStateActive(rt?.stopMessageState)) {
+        return true;
+    }
+    return hasPersistedActiveStopMessageState(metadata);
+}
+function hasPersistedActiveStopMessageState(metadata) {
+    const sessionScope = resolveStopMessageSessionScope(metadata);
+    if (!sessionScope) {
+        return false;
+    }
+    try {
+        const persisted = loadRoutingInstructionStateSync(sessionScope);
+        return isStopMessageStateActive(persisted);
+    }
+    catch {
+        return false;
+    }
+}
+function resolveStopMessageSessionScope(metadata) {
+    const sessionId = readString(metadata.sessionId);
+    if (sessionId) {
+        return 'session:' + sessionId;
+    }
+    const conversationId = readString(metadata.conversationId);
+    if (conversationId) {
+        return 'conversation:' + conversationId;
+    }
+    return undefined;
+}
+function isStopMessageStateActive(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return false;
+    }
+    const record = raw;
+    const text = typeof record.stopMessageText === 'string' ? record.stopMessageText.trim() : '';
+    const maxRepeats = typeof record.stopMessageMaxRepeats === 'number' && Number.isFinite(record.stopMessageMaxRepeats)
+        ? Math.max(1, Math.floor(record.stopMessageMaxRepeats))
+        : 0;
+    const stageMode = typeof record.stopMessageStageMode === 'string' ? record.stopMessageStageMode.trim().toLowerCase() : '';
+    if (stageMode === 'off') {
+        return false;
+    }
+    if (text && maxRepeats > 0) {
+        return true;
+    }
+    return stageMode === 'on' || stageMode === 'auto';
+}
+function buildContinueExecutionOperations(metadata) {
+    const rt = readRuntimeMetadata(metadata);
+    if (rt?.serverToolFollowup === true) {
+        return [];
+    }
+    const sessionId = readString(metadata.sessionId);
+    const hasSessionId = Boolean(sessionId && sessionId.trim());
+    if (hasActiveStopMessageStateForContinueExecution(metadata)) {
+        logContinueExecution('skip_schema_due_stopmessage', { hasSessionId });
+        return [];
+    }
+    logContinueExecution('inject_schema', { hasSessionId });
+    const parameters = {
+        type: 'object',
+        properties: {},
+        required: [],
+        additionalProperties: false
+    };
+    const continueTool = {
+        type: 'function',
+        function: {
+            name: 'continue_execution',
+            description: 'No-op control tool. Use this before status summaries or before ending the turn. If you are about to send finish_reason=stop (or protocol-equivalent end_turn), do not end directly; emit a continue_execution tool call instead. Keep it lightweight. The server will auto-followup so execution continues, avoiding interruption and improving execution efficiency.',
+            parameters,
+            strict: true
+        }
+    };
+    return [
+        {
+            op: 'set_request_metadata_fields',
+            fields: { continueExecutionEnabled: true }
+        },
+        { op: 'append_tool_if_missing', toolName: 'continue_execution', tool: continueTool }
+    ];
+}
+function injectContinueExecutionDirectiveIntoUserMessage(request, metadata) {
+    const rt = readRuntimeMetadata(metadata);
+    if (rt?.serverToolFollowup === true) {
+        return request;
+    }
+    if (hasActiveStopMessageStateForContinueExecution(metadata)) {
+        const sessionId = readString(metadata.sessionId);
+        const hasSessionId = Boolean(sessionId && sessionId.trim());
+        logContinueExecution('skip_user_directive_due_stopmessage', { hasSessionId });
+        return request;
+    }
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    if (messages.length === 0) {
+        return request;
+    }
+    const hasDirective = messages.some((message) => {
+        if (!message || typeof message !== 'object' || message.role !== 'user') {
+            return false;
+        }
+        return messageContentContainsDirectiveMarker(message.content);
+    });
+    if (hasDirective) {
+        return request;
+    }
+    const lastUserIdx = findLastUserMessageIndex(messages);
+    if (lastUserIdx < 0) {
+        return request;
+    }
+    const nextMessages = messages.slice();
+    const target = nextMessages[lastUserIdx];
+    const nextContent = appendDirectiveToUserContent(target.content, CONTINUE_EXECUTION_SYSTEM_DIRECTIVE);
+    nextMessages[lastUserIdx] = {
+        ...target,
+        content: nextContent
+    };
+    const sessionId = readString(metadata.sessionId);
+    const hasSessionId = Boolean(sessionId && sessionId.trim());
+    logContinueExecution('inject_user_directive', { hasSessionId });
+    return {
+        ...request,
+        messages: nextMessages
+    };
+}
+function messageContentContainsDirectiveMarker(content) {
+    if (typeof content === 'string') {
+        return content.includes(CONTINUE_EXECUTION_SYSTEM_DIRECTIVE_MARKER);
+    }
+    if (!Array.isArray(content)) {
+        return false;
+    }
+    for (const part of content) {
+        if (!part || typeof part !== 'object') {
+            continue;
+        }
+        const text = typeof part.text === 'string' ? String(part.text) : '';
+        if (text.includes(CONTINUE_EXECUTION_SYSTEM_DIRECTIVE_MARKER)) {
+            return true;
+        }
+    }
+    return false;
+}
+function appendDirectiveToUserContent(content, directive) {
+    if (typeof content === 'string') {
+        const base = content.trimEnd();
+        return base.length ? `${base}\n\n${directive}` : directive;
+    }
+    if (!Array.isArray(content)) {
+        return directive;
+    }
+    const next = content.slice();
+    for (let idx = next.length - 1; idx >= 0; idx -= 1) {
+        const part = next[idx];
+        if (!part || typeof part !== 'object' || typeof part.text !== 'string') {
+            continue;
+        }
+        const base = String(part.text).trimEnd();
+        next[idx] = {
+            ...part,
+            text: base.length ? `${base}\n\n${directive}` : directive
+        };
+        return next;
+    }
+    next.push({ type: 'input_text', text: directive });
+    return next;
+}
 function resolveSessionIdForClock(metadata, request) {
     const candidate = readString(metadata.sessionId) ?? readString(request.metadata?.sessionId);
     return candidate && candidate.trim() ? candidate.trim() : null;
@@ -736,6 +919,219 @@ function stripClockClearDirectiveFromText(text) {
     const next = replaced.replace(/\n{3,}/g, '\n\n').trim();
     return { hadClear: true, next };
 }
+function unquoteMarkerToken(value) {
+    const trimmed = String(value || '').trim();
+    if (!trimmed) {
+        return '';
+    }
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function parseMarkerRecurrenceKind(raw) {
+    const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (!value) {
+        return undefined;
+    }
+    if (value === 'daily' || value === 'day') {
+        return 'daily';
+    }
+    if (value === 'weekly' || value === 'week') {
+        return 'weekly';
+    }
+    if (value === 'interval' || value === 'every_minutes' || value === 'every-minutes' || value === 'everyminutes') {
+        return 'interval';
+    }
+    return undefined;
+}
+function parseMarkerRecurrence(record) {
+    const recurrenceRaw = record.recurrence ?? record.repeat ?? record.cycle;
+    if (recurrenceRaw === undefined || recurrenceRaw === null || recurrenceRaw === false) {
+        return undefined;
+    }
+    let kind;
+    let everyMinutesRaw;
+    let maxRunsRaw;
+    if (typeof recurrenceRaw === 'string') {
+        kind = parseMarkerRecurrenceKind(recurrenceRaw);
+        everyMinutesRaw = record.everyMinutes;
+        maxRunsRaw = record.maxRuns;
+    }
+    else if (recurrenceRaw && typeof recurrenceRaw === 'object' && !Array.isArray(recurrenceRaw)) {
+        const recurrenceRecord = recurrenceRaw;
+        kind = parseMarkerRecurrenceKind(recurrenceRecord.kind ?? recurrenceRecord.type ?? recurrenceRecord.mode ?? recurrenceRecord.every);
+        everyMinutesRaw = recurrenceRecord.everyMinutes ?? recurrenceRecord.minutes ?? record.everyMinutes;
+        maxRunsRaw = recurrenceRecord.maxRuns ?? record.maxRuns;
+    }
+    if (!kind) {
+        return undefined;
+    }
+    const maxRuns = Number(maxRunsRaw);
+    if (!Number.isFinite(maxRuns) || Math.floor(maxRuns) <= 0) {
+        return undefined;
+    }
+    if (kind === 'interval') {
+        const everyMinutes = Number(everyMinutesRaw);
+        if (!Number.isFinite(everyMinutes) || Math.floor(everyMinutes) <= 0) {
+            return undefined;
+        }
+        return { kind: 'interval', maxRuns: Math.floor(maxRuns), everyMinutes: Math.floor(everyMinutes) };
+    }
+    return { kind, maxRuns: Math.floor(maxRuns) };
+}
+function parseClockScheduleDirectivePayload(payload) {
+    const raw = String(payload || '').trim();
+    if (!raw || /^clear$/i.test(raw)) {
+        return null;
+    }
+    const parseFromRecord = (record) => {
+        const timeRaw = typeof record.time === 'string' ? record.time :
+            typeof record.dueAt === 'string' ? record.dueAt :
+                typeof record.due_at === 'string' ? record.due_at :
+                    '';
+        const messageRaw = typeof record.message === 'string' ? record.message :
+            typeof record.task === 'string' ? record.task :
+                '';
+        const dueAt = String(timeRaw || '').trim();
+        const task = String(messageRaw || '').trim();
+        const dueAtMs = parseDueAtMs(dueAt);
+        if (!dueAtMs || !task) {
+            return null;
+        }
+        const hasRecurrenceRaw = Object.prototype.hasOwnProperty.call(record, 'recurrence')
+            || Object.prototype.hasOwnProperty.call(record, 'repeat')
+            || Object.prototype.hasOwnProperty.call(record, 'cycle');
+        const recurrence = parseMarkerRecurrence(record);
+        if (hasRecurrenceRaw && !recurrence) {
+            return null;
+        }
+        return {
+            dueAtMs,
+            dueAt: new Date(dueAtMs).toISOString(),
+            task,
+            ...(recurrence ? { recurrence } : {})
+        };
+    };
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            const fromJson = parseFromRecord(parsed);
+            if (fromJson) {
+                return fromJson;
+            }
+        }
+    }
+    catch {
+        // fall through to loose parser
+    }
+    const loose = /^\{\s*time\s*:\s*([^,}]+)\s*,\s*message\s*:\s*([^}]+)\s*\}$/i.exec(raw);
+    if (!loose) {
+        return null;
+    }
+    const dueAt = unquoteMarkerToken(loose[1]);
+    const task = unquoteMarkerToken(loose[2]);
+    const dueAtMs = parseDueAtMs(dueAt);
+    if (!dueAtMs || !task) {
+        return null;
+    }
+    return {
+        dueAtMs,
+        dueAt: new Date(dueAtMs).toISOString(),
+        task
+    };
+}
+function extractClockScheduleDirectivesFromText(text) {
+    const pattern = /<\*\*\s*clock\s*:\s*([\s\S]*?)\s*\*\*>/gi;
+    const directives = [];
+    const next = String(text || '').replace(pattern, (full, payload) => {
+        const parsed = parseClockScheduleDirectivePayload(String(payload || ''));
+        if (!parsed) {
+            return full;
+        }
+        directives.push(parsed);
+        return '';
+    });
+    return {
+        directives,
+        next: next.replace(/\n{3,}/g, '\n\n').trim()
+    };
+}
+function extractClockScheduleDirectivesFromContent(content) {
+    if (typeof content === 'string') {
+        const result = extractClockScheduleDirectivesFromText(content);
+        return { directives: result.directives, next: result.next };
+    }
+    if (Array.isArray(content)) {
+        const directives = [];
+        const next = content.map((part) => {
+            if (typeof part === 'string') {
+                const result = extractClockScheduleDirectivesFromText(part);
+                if (result.directives.length) {
+                    directives.push(...result.directives);
+                }
+                return result.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 result = extractClockScheduleDirectivesFromText(text);
+                if (result.directives.length) {
+                    directives.push(...result.directives);
+                }
+                return { ...block, text: result.next };
+            }
+            return part;
+        });
+        return { directives, next };
+    }
+    return { directives: [], next: content };
+}
+let clockMarkerCallSeq = 0;
+function buildClockMarkerCallId(requestId, index) {
+    clockMarkerCallSeq += 1;
+    const token = String(requestId || 'req').replace(/[^a-zA-Z0-9_-]+/g, '_') || 'req';
+    return `call_clock_marker_${token}_${index + 1}_${clockMarkerCallSeq}`;
+}
+function buildClockMarkerScheduleMessages(requestId, markerIndex, marker, payload) {
+    const callId = buildClockMarkerCallId(requestId, markerIndex);
+    const args = {
+        action: 'schedule',
+        items: [
+            {
+                dueAt: marker.dueAt,
+                task: marker.task,
+                ...(marker.recurrence ? { recurrence: marker.recurrence } : {})
+            }
+        ]
+    };
+    return [
+        {
+            role: 'assistant',
+            content: null,
+            tool_calls: [
+                {
+                    id: callId,
+                    type: 'function',
+                    function: {
+                        name: 'clock',
+                        arguments: JSON.stringify(args)
+                    }
+                }
+            ]
+        },
+        {
+            role: 'tool',
+            tool_call_id: callId,
+            name: 'clock',
+            content: JSON.stringify(payload)
+        }
+    ];
+}
 function stripClockClearDirectiveFromContent(content) {
     if (typeof content === 'string') {
         const { hadClear, next } = stripClockClearDirectiveFromText(content);
@@ -781,7 +1177,8 @@ function findLastUserMessageIndex(messages) {
 async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, requestId) {
     const rt = readRuntimeMetadata(metadata);
     // Do not inject reminders or apply clock directives during internal servertool followup hops.
-    if (rt?.serverToolFollowup === true) {
+    const allowClockFollowupReminderInjection = rt?.clockFollowupInjectReminders === true;
+    if (rt?.serverToolFollowup === true && !allowClockFollowupReminderInjection) {
         return request;
     }
     const rawConfig = rt?.clock;
@@ -800,14 +1197,17 @@ async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, re
     const lastUserIdx = findLastUserMessageIndex(messages);
     // 1) Apply <**clock:clear**> directive (latest user message only).
     let hadClear = false;
+    let clockScheduleDirectives = [];
     let baseMessages = messages;
     if (lastUserIdx >= 0) {
         const lastUser = messages[lastUserIdx];
         const stripped = stripClockClearDirectiveFromContent(lastUser.content);
         hadClear = stripped.hadClear;
-        if (hadClear) {
+        const extracted = extractClockScheduleDirectivesFromContent(stripped.next);
+        clockScheduleDirectives = extracted.directives;
+        if (hadClear || clockScheduleDirectives.length > 0) {
             baseMessages = messages.slice();
-            baseMessages[lastUserIdx] = { ...lastUser, content: stripped.next };
+            baseMessages[lastUserIdx] = { ...lastUser, content: extracted.next };
         }
     }
     if (hadClear) {
@@ -822,7 +1222,54 @@ async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, re
         }
         // Continue: still inject per-request time tag (but skip due reminders).
     }
-    // 2) Inject due reminders as a user message + attach reservation for response-side commit.
+    // 2) Apply private schedule directives: <**clock:{time,message}**>
+    // Convert to actual clock scheduling and append synthetic tool_call/tool_result messages
+    // so downstream model sees canonical tool semantics.
+    let markerToolMessages = [];
+    if (clockScheduleDirectives.length > 0) {
+        for (let index = 0; index < clockScheduleDirectives.length; index += 1) {
+            const marker = clockScheduleDirectives[index];
+            const itemBase = {
+                dueAtMs: marker.dueAtMs,
+                task: marker.task,
+                ...(marker.recurrence ? { recurrence: marker.recurrence } : {})
+            };
+            const now = Date.now();
+            const guardedItem = marker.dueAtMs <= now + clockConfig.dueWindowMs
+                ? { ...itemBase, notBeforeRequestId: requestId }
+                : itemBase;
+            if (!sessionId) {
+                markerToolMessages = markerToolMessages.concat(buildClockMarkerScheduleMessages(requestId, index, marker, {
+                    ok: false,
+                    action: 'schedule',
+                    message: 'clock requires sessionId (x-session-id header or metadata.sessionId).'
+                }));
+                continue;
+            }
+            try {
+                const scheduled = await scheduleClockTasks(sessionId, [guardedItem], clockConfig);
+                markerToolMessages = markerToolMessages.concat(buildClockMarkerScheduleMessages(requestId, index, marker, {
+                    ok: true,
+                    action: 'schedule',
+                    scheduled: scheduled.map((entry) => ({
+                        taskId: entry.taskId,
+                        dueAt: new Date(entry.dueAtMs).toISOString(),
+                        task: entry.task,
+                        deliveryCount: entry.deliveryCount
+                    }))
+                }));
+                logClock('schedule', { sessionId, count: scheduled.length, source: 'marker' });
+            }
+            catch (error) {
+                markerToolMessages = markerToolMessages.concat(buildClockMarkerScheduleMessages(requestId, index, marker, {
+                    ok: false,
+                    action: 'schedule',
+                    message: `clock.schedule failed: ${error instanceof Error ? error.message : String(error ?? 'unknown')}`
+                }));
+            }
+        }
+    }
+    // 3) Inject due reminders as a user message + attach reservation for response-side commit.
     let reservation = null;
     let dueInjectText = '';
     if (!hadClear && sessionId) {
@@ -850,17 +1297,17 @@ async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, re
             content: [
                 '[Clock Reminder]: scheduled tasks are due.',
                 dueInjectText,
-                'You may call tools to complete these tasks. If the tool list is incomplete, standard tools have been injected.'
+                'You may call tools to complete these tasks. If the tool list is incomplete, standard tools have been injected. MANDATORY: if waiting is needed, use the clock tool to schedule wake-up (clock.schedule) now; do not only promise to wait.'
             ].join('\n')
         };
     })();
-    // 3) When we have due tasks, ensure a standard tool set is present (best-effort).
+    // 4) When we have due tasks, ensure a standard tool set is present (best-effort).
     let nextRequest = request;
     if (dueUserMessage) {
         const ensureToolsOps = buildClockStandardToolsOperations();
         nextRequest = applyHubOperations(nextRequest, ensureToolsOps);
     }
-    // 4) Per-request time injection (user time tag or paired clock.get tool result).
+    // 5) Per-request time injection (user time tag or paired clock.get tool result).
     let snapshot = null;
     try {
         snapshot = await getClockTimeSnapshot();
@@ -882,7 +1329,10 @@ async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, re
             __clockReservation: reservation
         }
         : baseMetadata;
-    const messagesWithDue = dueUserMessage ? [...baseMessages, dueUserMessage] : baseMessages.slice();
+    const messagesWithMarkers = markerToolMessages.length > 0
+        ? [...baseMessages, ...markerToolMessages]
+        : baseMessages.slice();
+    const messagesWithDue = dueUserMessage ? [...messagesWithMarkers, dueUserMessage] : messagesWithMarkers;
     // Always inject time via user-role content to keep the tag visible without adding
     // extra tool-call semantics that may distract the model.
     //