@jsonstudio/rcc 0.90.876 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/servertool/engine.js

@@ -12,10 +12,14 @@ import { resolveClockSessionScope } from './clock/session-scope.js';
 import { savePendingServerToolInjection } from './pending-session.js';
 import { appendServerToolProgressFileEvent } from './log/progress-file.js';
 import { attachStopGatewayContext, inspectStopGatewaySignal } from './stop-gateway-context.js';
+import { isStopEligibleForServerTool } from './stop-gateway-context.js';
+import { readReasoningStopState, syncReasoningStopModeFromRequest } from './handlers/reasoning-stop-state.js';
+import { getServerToolHandler } from './registry.js';
 import { formatStopMessageCompareContext, readStopMessageCompareContext } from './stop-message-compare-context.js';
 const STOP_MESSAGE_STAGE_TIMEOUT_MS = 900_000;
 const STOP_MESSAGE_LOOP_WARN_THRESHOLD = 5;
 const STOP_MESSAGE_LOOP_FAIL_THRESHOLD = 10;
+const FOLLOWUP_ERROR_REASON_MAX_LENGTH = 220;
 function logServerToolNonBlocking(stage, error, details) {
     const message = error instanceof Error ? error.message : String(error ?? 'unknown');
     const detailEntries = details && typeof details === 'object'
@@ -36,12 +40,12 @@ function parseTimeoutMs(raw, fallback) {
 function resolveServerToolTimeoutMs() {
     return parseTimeoutMs(process.env.ROUTECODEX_SERVERTOOL_TIMEOUT_MS ||
         process.env.RCC_SERVERTOOL_TIMEOUT_MS ||
-        process.env.LLMSWITCH_SERVERTOOL_TIMEOUT_MS, 500_000);
+        process.env.LLMSWITCH_SERVERTOOL_TIMEOUT_MS, 0);
 }
-function resolveServerToolFollowupTimeoutMs(fallback) {
+function resolveServerToolFollowupTimeoutMs(_fallback) {
     return parseTimeoutMs(process.env.ROUTECODEX_SERVERTOOL_FOLLOWUP_TIMEOUT_MS ||
         process.env.RCC_SERVERTOOL_FOLLOWUP_TIMEOUT_MS ||
-        process.env.LLMSWITCH_SERVERTOOL_FOLLOWUP_TIMEOUT_MS, fallback);
+        process.env.LLMSWITCH_SERVERTOOL_FOLLOWUP_TIMEOUT_MS, 0);
 }
 function parseBooleanLike(value) {
     if (value === true) {
@@ -72,6 +76,61 @@ function normalizeClientInjectText(value, fallback = '继续执行') {
     const sanitized = sanitizeFollowupText(text);
     return sanitized || fallback;
 }
+function compactFollowupErrorReason(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().replace(/\s+/g, ' ');
+    if (!normalized) {
+        return undefined;
+    }
+    const httpCodeMatch = normalized.match(/^http\s+(\d{3})\s*:/i) ||
+        normalized.match(/\bhttp\s+(\d{3})\b/i);
+    if (httpCodeMatch?.[1]) {
+        return `HTTP_${httpCodeMatch[1]}`;
+    }
+    if (/<\s*!doctype\s+html\b/i.test(normalized) || /<\s*html\b/i.test(normalized)) {
+        return 'UPSTREAM_HTML_ERROR';
+    }
+    if (normalized.length <= FOLLOWUP_ERROR_REASON_MAX_LENGTH) {
+        return normalized;
+    }
+    return `${normalized.slice(0, FOLLOWUP_ERROR_REASON_MAX_LENGTH)}…`;
+}
+function resolveAdapterContextProviderKey(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
+        return '';
+    }
+    const record = adapterContext;
+    const direct = typeof record.providerKey === 'string' && record.providerKey.trim().length
+        ? record.providerKey.trim()
+        : typeof record.targetProviderKey === 'string' && record.targetProviderKey.trim().length
+            ? record.targetProviderKey.trim()
+            : '';
+    if (direct) {
+        return direct;
+    }
+    const target = record.target && typeof record.target === 'object' && !Array.isArray(record.target)
+        ? record.target
+        : null;
+    if (target) {
+        const targetProviderKey = typeof target.providerKey === 'string' && target.providerKey.trim().length
+            ? target.providerKey.trim()
+            : typeof target.providerId === 'string' && target.providerId.trim().length
+                ? target.providerId.trim()
+                : '';
+        if (targetProviderKey) {
+            return targetProviderKey;
+        }
+    }
+    return '';
+}
+function isReasoningStopContinueFlow(flowId) {
+    return typeof flowId === 'string' && flowId.trim() === 'reasoning_stop_continue_flow';
+}
+function isReasoningStopGuardFlow(flowId) {
+    return typeof flowId === 'string' && flowId.trim() === 'reasoning_stop_guard_flow';
+}
 function extractAppendUserTextFromFollowupPlan(followupPlan) {
     if (!followupPlan || typeof followupPlan !== 'object' || Array.isArray(followupPlan)) {
         return undefined;
@@ -360,6 +419,31 @@ function createEmptyFollowupError(args) {
     wrapped.cause = args.lastError;
     return wrapped;
 }
+function createMissingFollowupPayloadError(args) {
+    const followupPlanRecord = args.followupPlan && typeof args.followupPlan === 'object' && !Array.isArray(args.followupPlan)
+        ? args.followupPlan
+        : undefined;
+    const capturedChatRequest = args.adapterContext?.capturedChatRequest;
+    const seedAvailable = Boolean(extractCapturedChatSeed(capturedChatRequest));
+    const wrapped = new ProviderProtocolError('[servertool] followup payload missing for non-clientInject flow', {
+        code: 'SERVERTOOL_FOLLOWUP_FAILED',
+        category: 'INTERNAL_ERROR',
+        details: {
+            flowId: args.flowId,
+            requestId: args.requestId,
+            reason: 'followup_payload_missing',
+            hasPayloadPlan: Boolean(followupPlanRecord && Object.prototype.hasOwnProperty.call(followupPlanRecord, 'payload')),
+            hasInjectionPlan: Boolean(followupPlanRecord && Object.prototype.hasOwnProperty.call(followupPlanRecord, 'injection')),
+            hasMetadataPlan: Boolean(followupPlanRecord && Object.prototype.hasOwnProperty.call(followupPlanRecord, 'metadata')),
+            hasCapturedChatRequest: Boolean(capturedChatRequest &&
+                typeof capturedChatRequest === 'object' &&
+                !Array.isArray(capturedChatRequest)),
+            capturedSeedAvailable: seedAvailable
+        }
+    });
+    wrapped.status = 502;
+    return wrapped;
+}
 function isStopFinishReasonWithoutToolCalls(base) {
     return inspectStopGatewaySignal(base).eligible;
 }
@@ -403,6 +487,70 @@ async function shouldDisableServerToolTimeoutForClockHold(args) {
         return false;
     }
 }
+function createServerToolEngineRunner(args) {
+    return (overrides) => withTimeout(runServerSideToolEngine({
+        ...args.engineOptions,
+        ...overrides
+    }), args.effectiveServerToolTimeoutMs, () => createServerToolTimeoutError({
+        requestId: args.requestId,
+        phase: 'engine',
+        timeoutMs: args.effectiveServerToolTimeoutMs || args.serverToolTimeoutMs
+    }));
+}
+async function runReasoningStopGuardPrepass(args) {
+    // ReasoningStopGuard: dedicated orchestration for finish_reason=stop (post-phase hook)
+    // Must run BEFORE stop_message_auto to enforce stopless mode constraints.
+    const reasoningStopMode = syncReasoningStopModeFromRequest(args.adapterContext);
+    const reasoningStopGuardHandler = getServerToolHandler('reasoning_stop_guard');
+    const reasoningStopGuardEnabled = reasoningStopGuardHandler && reasoningStopGuardHandler.trigger === 'auto';
+    const reasoningStopEligible = isStopEligibleForServerTool(args.chat, args.adapterContext);
+    if (!args.stopSignal.observed ||
+        !reasoningStopGuardEnabled ||
+        !reasoningStopEligible ||
+        reasoningStopMode === 'off') {
+        return null;
+    }
+    args.logProgress(0, 5, 'reasoning_stop_guard_check', { flowId: 'reasoning_stop_guard_flow' });
+    const guardResult = await args.runEngine({
+        disableToolCallHandlers: true,
+        includeAutoHookIds: ['reasoning_stop_guard'],
+        excludeAutoHookIds: ['stop_message_auto']
+    });
+    if (!guardResult.execution?.flowId) {
+        return null;
+    }
+    const guardFlowId = guardResult.execution.flowId;
+    args.logProgress(1, 5, 'matched', { flowId: guardFlowId });
+    args.logStopEntry('trigger', 'reasoning_stop_guard_activated', {
+        flowId: guardFlowId,
+        reason: args.stopSignal.reason,
+        source: args.stopSignal.source,
+        eligible: args.stopSignal.eligible
+    });
+    if (guardFlowId === 'reasoning_stop_finalize_flow') {
+        args.logProgress(5, 5, 'completed (reasoning_stop_finalize)', { flowId: guardFlowId });
+        return {
+            chat: guardResult.finalChatResponse,
+            executed: true,
+            flowId: guardFlowId
+        };
+    }
+    return null;
+}
+async function runPrimaryServerToolEngineSelection(args) {
+    // StopMessage owns a dedicated orchestration skeleton:
+    // same trigger/processing semantics as before, but isolated from the generic servertool queue.
+    let engineResult = await args.runEngine({
+        disableToolCallHandlers: true,
+        includeAutoHookIds: ['stop_message_auto']
+    });
+    if (engineResult.mode === 'passthrough' || !engineResult.execution) {
+        engineResult = await args.runEngine({
+            excludeAutoHookIds: ['stop_message_auto']
+        });
+    }
+    return engineResult;
+}
 export async function runServerToolOrchestration(options) {
     const BLUE = '\x1b[38;5;39m';
     const YELLOW = '\x1b[38;5;214m';
@@ -414,11 +562,12 @@ export async function runServerToolOrchestration(options) {
             return 'unknown';
         const mapping = {
             continue_execution_flow: 'continue_execution',
-            review_flow: 'review',
+            reasoning_stop_flow: 'reasoning.stop',
+            reasoning_stop_guard_flow: 'reasoning_stop_guard',
+            reasoning_stop_finalize_flow: 'reasoning_stop_finalize',
             stop_message_flow: 'stop_message_auto',
             apply_patch_guard: 'apply_patch_guard',
             exec_command_guard: 'exec_command_guard',
-            iflow_model_error_retry: 'iflow_model_error_retry',
             antigravity_thought_signature_bootstrap: 'antigravity_thought_signature_bootstrap',
             web_search_flow: 'web_search',
             vision_flow: 'vision_auto',
@@ -639,25 +788,25 @@ export async function runServerToolOrchestration(options) {
         clientInjectDispatch: options.clientInjectDispatch,
         onAutoHookTrace: logAutoHookTrace
     };
-    const runEngine = async (overrides) => withTimeout(runServerSideToolEngine({
-        ...engineOptions,
-        ...overrides
-    }), effectiveServerToolTimeoutMs, () => createServerToolTimeoutError({
-        requestId: options.requestId,
-        phase: 'engine',
-        timeoutMs: effectiveServerToolTimeoutMs || serverToolTimeoutMs
-    }));
-    // StopMessage owns a dedicated orchestration skeleton:
-    // same trigger/processing semantics as before, but isolated from the generic servertool queue.
-    let engineResult = await runEngine({
-        disableToolCallHandlers: true,
-        includeAutoHookIds: ['stop_message_auto']
+    const runEngine = createServerToolEngineRunner({
+        engineOptions,
+        effectiveServerToolTimeoutMs,
+        serverToolTimeoutMs,
+        requestId: options.requestId
     });
-    if (engineResult.mode === 'passthrough' || !engineResult.execution) {
-        engineResult = await runEngine({
-            excludeAutoHookIds: ['stop_message_auto']
-        });
+    const reasoningStopState = readReasoningStopState(options.adapterContext);
+    const guardPrepassResult = await runReasoningStopGuardPrepass({
+        chat: options.chat,
+        adapterContext: options.adapterContext,
+        stopSignal,
+        runEngine,
+        logProgress,
+        logStopEntry
+    });
+    if (guardPrepassResult) {
+        return guardPrepassResult;
     }
+    const engineResult = await runPrimaryServerToolEngineSelection({ runEngine });
     if (engineResult.mode === 'passthrough' || !engineResult.execution) {
         const skipReason = engineResult.mode === 'passthrough' ? 'passthrough' : 'no_execution';
         if (stopSignal.observed) {
@@ -767,11 +916,16 @@ export async function runServerToolOrchestration(options) {
     const isStopMessageFlow = engineResult.execution.flowId === 'stop_message_flow';
     const isClockHoldFlow = engineResult.execution.flowId === 'clock_hold_flow';
     const isContinueExecutionFlow = engineResult.execution.flowId === 'continue_execution_flow';
-    const isReviewFlow = engineResult.execution.flowId === 'review_flow';
     const isApplyPatchGuard = engineResult.execution.flowId === 'apply_patch_guard';
     const isExecCommandGuard = engineResult.execution.flowId === 'exec_command_guard';
-    const isErrorAutoFlow = engineResult.execution.flowId === 'iflow_model_error_retry';
-    const applyAutoLimit = isErrorAutoFlow || isApplyPatchGuard || isExecCommandGuard;
+    const isReasoningOnlyContinueFlow = engineResult.execution.flowId === 'reasoning_only_continue_flow';
+    const isReasoningStopGuardFlow = engineResult.execution.flowId === 'reasoning_stop_guard_flow';
+    const isReasoningStopContinueFlow = engineResult.execution.flowId === 'reasoning_stop_continue_flow';
+    const applyAutoLimit = isApplyPatchGuard
+        || isExecCommandGuard
+        || isReasoningOnlyContinueFlow
+        || isReasoningStopGuardFlow
+        || isReasoningStopContinueFlow;
     // ServerTool followups must not inherit or inject any routeHint; always route fresh.
     const preserveRouteHint = false;
     const followupPlan = engineResult.execution.followup;
@@ -804,19 +958,6 @@ export async function runServerToolOrchestration(options) {
         }
         return null;
     })();
-    const metadataOnlyFollowup = !followupPayloadRaw &&
-        Boolean(followupPlan &&
-            typeof followupPlan === 'object' &&
-            !Array.isArray(followupPlan) &&
-            Object.prototype.hasOwnProperty.call(followupPlan, 'metadata'));
-    if (!followupPayloadRaw && !metadataOnlyFollowup) {
-        logProgress(5, totalSteps, 'completed (missing followup payload)', { flowId });
-        return {
-            chat: engineResult.finalChatResponse,
-            executed: true,
-            flowId: engineResult.execution.flowId
-        };
-    }
     const loopPayload = followupPayloadRaw ||
         (engineResult.execution.flowId === 'stop_message_flow'
             ? buildStopMessageLoopPayload(options.adapterContext)
@@ -875,23 +1016,7 @@ export async function runServerToolOrchestration(options) {
         stream: false,
         ...(engineResult.execution.followup.metadata ?? {})
     };
-    const forceReenterFollowup = isStopMessageFlow || isReviewFlow;
     const forceTmuxClientInjectFollowup = isClockHoldFlow || engineResult.execution.flowId === 'heartbeat_flow';
-    if (forceReenterFollowup && readClientInjectOnly(metadata)) {
-        const reenterText = normalizeClientInjectText(metadata.clientInjectText, '继续执行');
-        followupPayloadRaw = buildServerToolFollowupChatPayloadFromInjection({
-            adapterContext: options.adapterContext,
-            chatResponse: engineResult.finalChatResponse,
-            injection: {
-                ops: [
-                    { op: 'append_assistant_message', required: false },
-                    { op: 'append_user_text', text: reenterText }
-                ]
-            }
-        });
-        delete metadata.clientInjectOnly;
-        delete metadata.clientInjectText;
-    }
     if (forceTmuxClientInjectFollowup && !readClientInjectOnly(metadata)) {
         const clientInjectText = normalizeClientInjectText(metadata.clientInjectText ??
             extractAppendUserTextFromFollowupPlan(followupPlan) ??
@@ -926,9 +1051,14 @@ export async function runServerToolOrchestration(options) {
     // For stateful auto-followups (e.g. stop_message_flow / clock_hold_flow / continue_execution_flow),
     // keep the same providerKey/alias.
     // Otherwise the followup requestId suffix would cause round-robin alias switching and compatibility drift.
-    if (isStopMessageFlow || isClockHoldFlow || isContinueExecutionFlow || isReviewFlow) {
-        const providerKeyRaw = options.adapterContext.providerKey;
-        const providerKey = typeof providerKeyRaw === 'string' && providerKeyRaw.trim().length ? providerKeyRaw.trim() : '';
+    if (isStopMessageFlow || isClockHoldFlow || isContinueExecutionFlow) {
+        const providerKey = resolveAdapterContextProviderKey(options.adapterContext);
+        if (providerKey) {
+            metadata.__shadowCompareForcedProviderKey = providerKey;
+        }
+    }
+    if ((isReasoningStopGuardFlow || isReasoningStopContinueFlow) && !metadata.__shadowCompareForcedProviderKey) {
+        const providerKey = resolveAdapterContextProviderKey(options.adapterContext);
         if (providerKey) {
             metadata.__shadowCompareForcedProviderKey = providerKey;
         }
@@ -936,9 +1066,16 @@ export async function runServerToolOrchestration(options) {
     const retryEmptyFollowupOnce = isStopMessageFlow;
     const maxAttempts = retryEmptyFollowupOnce ? 2 : 1;
     const followupRequestId = buildFollowupRequestId(options.requestId, engineResult.execution.followup.requestIdSuffix);
-    const clientInjectOnlyRaw = metadata.clientInjectOnly;
-    const clientInjectOnly = clientInjectOnlyRaw === true ||
-        (typeof clientInjectOnlyRaw === 'string' && clientInjectOnlyRaw.trim().toLowerCase() === 'true');
+    const clientInjectOnly = readClientInjectOnly(metadata);
+    if (!followupPayloadRaw && !clientInjectOnly) {
+        logProgress(5, totalSteps, 'failed (missing followup payload; fail-fast)', { flowId });
+        throw createMissingFollowupPayloadError({
+            flowId: engineResult.execution.flowId,
+            requestId: options.requestId,
+            followupPlan,
+            adapterContext: options.adapterContext
+        });
+    }
     if (clientInjectOnly) {
         if (!options.clientInjectDispatch) {
             const wrapped = new ProviderProtocolError('[servertool] client inject dispatcher unavailable', {
@@ -1039,13 +1176,17 @@ export async function runServerToolOrchestration(options) {
         throw wrapped;
     }
     if (!followupPayloadRaw) {
-        const decorated = decorateFinalChatWithServerToolContext(engineResult.finalChatResponse, engineResult.execution);
-        logProgress(5, totalSteps, 'completed (metadata-only followup without payload)', { flowId });
-        return {
-            chat: decorated,
-            executed: true,
-            flowId: engineResult.execution.flowId
-        };
+        const wrapped = new ProviderProtocolError('[servertool] followup payload missing unexpectedly', {
+            code: 'SERVERTOOL_FOLLOWUP_FAILED',
+            category: 'INTERNAL_ERROR',
+            details: {
+                flowId: engineResult.execution.flowId,
+                requestId: options.requestId,
+                reason: 'followup_payload_missing_after_validation'
+            }
+        });
+        wrapped.status = 502;
+        throw wrapped;
     }
     // Build followup payload for non-client-inject flows
     let followupPayload = coerceFollowupPayloadStream(followupPayloadRaw, metadata.stream === true);
@@ -1150,6 +1291,34 @@ export async function runServerToolOrchestration(options) {
                     logProgress(5, totalSteps, 'failed (stopMessage followup failed; state cleared)', { flowId, attempt });
                     throw error;
                 }
+                const errorRecord = error && typeof error === 'object' && !Array.isArray(error)
+                    ? error
+                    : undefined;
+                const errorDetails = errorRecord?.details && typeof errorRecord.details === 'object' && !Array.isArray(errorRecord.details)
+                    ? errorRecord.details
+                    : undefined;
+                const upstreamCode = (typeof errorRecord?.upstreamCode === 'string' && errorRecord.upstreamCode.trim())
+                    || (typeof errorDetails?.upstreamCode === 'string' && errorDetails.upstreamCode.trim())
+                    || undefined;
+                const upstreamStatus = (typeof errorRecord?.status === 'number' && Number.isFinite(errorRecord.status)
+                    ? Math.floor(errorRecord.status)
+                    : undefined)
+                    || (typeof errorRecord?.statusCode === 'number' && Number.isFinite(errorRecord.statusCode)
+                        ? Math.floor(errorRecord.statusCode)
+                        : undefined)
+                    || (typeof errorDetails?.status === 'number' && Number.isFinite(errorDetails.status)
+                        ? Math.floor(errorDetails.status)
+                        : undefined)
+                    || (typeof errorDetails?.statusCode === 'number' && Number.isFinite(errorDetails.statusCode)
+                        ? Math.floor(errorDetails.statusCode)
+                        : undefined)
+                    || undefined;
+                const reason = (typeof errorDetails?.reason === 'string' && errorDetails.reason.trim())
+                    || (typeof errorRecord?.reason === 'string' && errorRecord.reason.trim())
+                    || (error instanceof Error && error.message ? error.message : undefined)
+                    || undefined;
+                const compactReason = compactFollowupErrorReason(reason);
+                const compactErrorMessage = compactFollowupErrorReason(error instanceof Error ? error.message : String(error ?? 'unknown'));
                 const wrapped = new ProviderProtocolError(`[servertool] Followup failed for flow ${engineResult.execution.flowId ?? 'unknown'} ` +
                     `(attempt ${attempt}/${maxAttempts})`, {
                     code: 'SERVERTOOL_FOLLOWUP_FAILED',
@@ -1158,9 +1327,20 @@ export async function runServerToolOrchestration(options) {
                         requestId: options.requestId,
                         attempt,
                         maxAttempts,
-                        error: error instanceof Error ? error.message : String(error ?? 'unknown')
+                        error: compactErrorMessage ?? 'unknown',
+                        ...(compactReason ? { reason: compactReason } : {}),
+                        ...(upstreamCode ? { upstreamCode } : {})
                     }
                 });
+                if (compactReason) {
+                    wrapped.reason = compactReason;
+                }
+                if (upstreamCode) {
+                    wrapped.upstreamCode = upstreamCode;
+                }
+                if (typeof upstreamStatus === 'number' && upstreamStatus > 0) {
+                    wrapped.status = upstreamStatus;
+                }
                 wrapped.cause = error;
                 throw wrapped;
             }
@@ -1246,8 +1426,7 @@ export async function runServerToolOrchestration(options) {
                 (typeof options.entryEndpoint === 'string' && options.entryEndpoint.trim().length
                     ? options.entryEndpoint
                     : followupEntryEndpoint);
-            const forcedProviderKeyRaw = options.adapterContext?.providerKey;
-            const forcedProviderKey = typeof forcedProviderKeyRaw === 'string' && forcedProviderKeyRaw.trim().length ? forcedProviderKeyRaw.trim() : '';
+            const forcedProviderKey = resolveAdapterContextProviderKey(options.adapterContext);
             if (forcedProviderKey) {
                 replayMetadata.__shadowCompareForcedProviderKey = forcedProviderKey;
             }
@@ -1523,7 +1702,12 @@ function buildServerToolLoopState(adapterContext, flowId, payload, response) {
     if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
         return null;
     }
-    const trackPayload = typeof flowId === 'string' && flowId.trim() && flowId !== 'stop_message_flow';
+    const useFlowOnlyAutoLimit = flowId === 'apply_patch_guard'
+        || flowId === 'exec_command_guard'
+        || flowId === 'reasoning_only_continue_flow'
+        || flowId === 'reasoning_stop_guard_flow'
+        || flowId === 'reasoning_stop_continue_flow';
+    const trackPayload = typeof flowId === 'string' && flowId.trim() && flowId !== 'stop_message_flow' && !useFlowOnlyAutoLimit;
     const payloadHash = trackPayload ? hashPayload(payload) : '__servertool_auto__';
     if (!payloadHash) {
         return null;

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/clock.js

@@ -138,6 +138,12 @@ function stripClockStopMarkerFromText(raw) {
     }
     return { updated: kept.join('\n'), changed };
 }
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error ?? 'unknown');
+}
 async function clearClockStopMarkerForReactivation(adapterContext) {
     const workdir = resolveWorkingDirectoryFromAdapterContextOrFallback(adapterContext);
     if (!workdir) {
@@ -502,7 +508,13 @@ const handler = async (ctx) => {
             logClock('update_miss', { sessionId, taskId });
             return respond({ ok: false, action, message: 'clock.update failed: task not found or patch invalid' });
         }
-        await clearClockStopMarkerForReactivation(ctx.adapterContext).catch(() => { });
+        await clearClockStopMarkerForReactivation(ctx.adapterContext).catch((error) => {
+            logClock('reactivate_clear_stop_marker_failed', {
+                sessionId,
+                action: 'update',
+                message: formatUnknownError(error)
+            });
+        });
         logClock('update', { sessionId, taskId });
         return respond({ ok: true, action, updated: mapTaskForTool(updated) });
     }
@@ -535,7 +547,13 @@ const handler = async (ctx) => {
         return item;
     });
     const scheduled = await scheduleClockTasks(sessionId, guardedItems, clockConfig);
-    await clearClockStopMarkerForReactivation(ctx.adapterContext).catch(() => { });
+    await clearClockStopMarkerForReactivation(ctx.adapterContext).catch((error) => {
+        logClock('reactivate_clear_stop_marker_failed', {
+            sessionId,
+            action: 'schedule',
+            message: formatUnknownError(error)
+        });
+    });
     logClock('schedule', { sessionId, count: scheduled.length });
     const allTasks = await listClockTasks(sessionId, clockConfig);
     const nearbyWarnings = buildNearbyReminderWarnings(scheduled, allTasks);