@nfreeness/clawdbot 0.124.22101 → 0.124.22103

package/dist/agents/tool-loop-detection.js

@@ -0,0 +1,466 @@
+import { createHash } from "node:crypto";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+import { isPlainObject } from "../utils.js";
+const log = createSubsystemLogger("agents/loop-detection");
+export const TOOL_CALL_HISTORY_SIZE = 30;
+export const WARNING_THRESHOLD = 10;
+export const CRITICAL_THRESHOLD = 20;
+export const GLOBAL_CIRCUIT_BREAKER_THRESHOLD = 30;
+const DEFAULT_LOOP_DETECTION_CONFIG = {
+    enabled: false,
+    historySize: TOOL_CALL_HISTORY_SIZE,
+    warningThreshold: WARNING_THRESHOLD,
+    criticalThreshold: CRITICAL_THRESHOLD,
+    globalCircuitBreakerThreshold: GLOBAL_CIRCUIT_BREAKER_THRESHOLD,
+    detectors: {
+        genericRepeat: true,
+        knownPollNoProgress: true,
+        pingPong: true,
+    },
+};
+function asPositiveInt(value, fallback) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        return fallback;
+    }
+    return value;
+}
+function resolveLoopDetectionConfig(config) {
+    let warningThreshold = asPositiveInt(config?.warningThreshold, DEFAULT_LOOP_DETECTION_CONFIG.warningThreshold);
+    let criticalThreshold = asPositiveInt(config?.criticalThreshold, DEFAULT_LOOP_DETECTION_CONFIG.criticalThreshold);
+    let globalCircuitBreakerThreshold = asPositiveInt(config?.globalCircuitBreakerThreshold, DEFAULT_LOOP_DETECTION_CONFIG.globalCircuitBreakerThreshold);
+    if (criticalThreshold <= warningThreshold) {
+        criticalThreshold = warningThreshold + 1;
+    }
+    if (globalCircuitBreakerThreshold <= criticalThreshold) {
+        globalCircuitBreakerThreshold = criticalThreshold + 1;
+    }
+    return {
+        enabled: config?.enabled ?? DEFAULT_LOOP_DETECTION_CONFIG.enabled,
+        historySize: asPositiveInt(config?.historySize, DEFAULT_LOOP_DETECTION_CONFIG.historySize),
+        warningThreshold,
+        criticalThreshold,
+        globalCircuitBreakerThreshold,
+        detectors: {
+            genericRepeat: config?.detectors?.genericRepeat ?? DEFAULT_LOOP_DETECTION_CONFIG.detectors.genericRepeat,
+            knownPollNoProgress: config?.detectors?.knownPollNoProgress ??
+                DEFAULT_LOOP_DETECTION_CONFIG.detectors.knownPollNoProgress,
+            pingPong: config?.detectors?.pingPong ?? DEFAULT_LOOP_DETECTION_CONFIG.detectors.pingPong,
+        },
+    };
+}
+/**
+ * Hash a tool call for pattern matching.
+ * Uses tool name + deterministic JSON serialization digest of params.
+ */
+export function hashToolCall(toolName, params) {
+    return `${toolName}:${digestStable(params)}`;
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    const obj = value;
+    const keys = Object.keys(obj).slice().sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+function digestStable(value) {
+    const serialized = stableStringifyFallback(value);
+    return createHash("sha256").update(serialized).digest("hex");
+}
+function stableStringifyFallback(value) {
+    try {
+        return stableStringify(value);
+    }
+    catch {
+        if (value === null || value === undefined) {
+            return `${value}`;
+        }
+        if (typeof value === "string") {
+            return value;
+        }
+        if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+            return `${value}`;
+        }
+        if (value instanceof Error) {
+            return `${value.name}:${value.message}`;
+        }
+        return Object.prototype.toString.call(value);
+    }
+}
+function isKnownPollToolCall(toolName, params) {
+    if (toolName === "command_status") {
+        return true;
+    }
+    if (toolName !== "process" || !isPlainObject(params)) {
+        return false;
+    }
+    const action = params.action;
+    return action === "poll" || action === "log";
+}
+function extractTextContent(result) {
+    if (!isPlainObject(result) || !Array.isArray(result.content)) {
+        return "";
+    }
+    return result.content
+        .filter((entry) => isPlainObject(entry) && typeof entry.type === "string" && typeof entry.text === "string")
+        .map((entry) => entry.text)
+        .join("\n")
+        .trim();
+}
+function formatErrorForHash(error) {
+    if (error instanceof Error) {
+        return error.message || error.name;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+        return `${error}`;
+    }
+    return stableStringify(error);
+}
+function hashToolOutcome(toolName, params, result, error) {
+    if (error !== undefined) {
+        return `error:${digestStable(formatErrorForHash(error))}`;
+    }
+    if (!isPlainObject(result)) {
+        return result === undefined ? undefined : digestStable(result);
+    }
+    const details = isPlainObject(result.details) ? result.details : {};
+    const text = extractTextContent(result);
+    if (isKnownPollToolCall(toolName, params) && toolName === "process" && isPlainObject(params)) {
+        const action = params.action;
+        if (action === "poll") {
+            return digestStable({
+                action,
+                status: details.status,
+                exitCode: details.exitCode ?? null,
+                exitSignal: details.exitSignal ?? null,
+                aggregated: details.aggregated ?? null,
+                text,
+            });
+        }
+        if (action === "log") {
+            return digestStable({
+                action,
+                status: details.status,
+                totalLines: details.totalLines ?? null,
+                totalChars: details.totalChars ?? null,
+                truncated: details.truncated ?? null,
+                exitCode: details.exitCode ?? null,
+                exitSignal: details.exitSignal ?? null,
+                text,
+            });
+        }
+    }
+    return digestStable({
+        details,
+        text,
+    });
+}
+function getNoProgressStreak(history, toolName, argsHash) {
+    let streak = 0;
+    let latestResultHash;
+    for (let i = history.length - 1; i >= 0; i -= 1) {
+        const record = history[i];
+        if (!record || record.toolName !== toolName || record.argsHash !== argsHash) {
+            continue;
+        }
+        if (typeof record.resultHash !== "string" || !record.resultHash) {
+            continue;
+        }
+        if (!latestResultHash) {
+            latestResultHash = record.resultHash;
+            streak = 1;
+            continue;
+        }
+        if (record.resultHash !== latestResultHash) {
+            break;
+        }
+        streak += 1;
+    }
+    return { count: streak, latestResultHash };
+}
+function getPingPongStreak(history, currentSignature) {
+    const last = history.at(-1);
+    if (!last) {
+        return { count: 0, noProgressEvidence: false };
+    }
+    let otherSignature;
+    let otherToolName;
+    for (let i = history.length - 2; i >= 0; i -= 1) {
+        const call = history[i];
+        if (!call) {
+            continue;
+        }
+        if (call.argsHash !== last.argsHash) {
+            otherSignature = call.argsHash;
+            otherToolName = call.toolName;
+            break;
+        }
+    }
+    if (!otherSignature || !otherToolName) {
+        return { count: 0, noProgressEvidence: false };
+    }
+    let alternatingTailCount = 0;
+    for (let i = history.length - 1; i >= 0; i -= 1) {
+        const call = history[i];
+        if (!call) {
+            continue;
+        }
+        const expected = alternatingTailCount % 2 === 0 ? last.argsHash : otherSignature;
+        if (call.argsHash !== expected) {
+            break;
+        }
+        alternatingTailCount += 1;
+    }
+    if (alternatingTailCount < 2) {
+        return { count: 0, noProgressEvidence: false };
+    }
+    const expectedCurrentSignature = otherSignature;
+    if (currentSignature !== expectedCurrentSignature) {
+        return { count: 0, noProgressEvidence: false };
+    }
+    const tailStart = Math.max(0, history.length - alternatingTailCount);
+    let firstHashA;
+    let firstHashB;
+    let noProgressEvidence = true;
+    for (let i = tailStart; i < history.length; i += 1) {
+        const call = history[i];
+        if (!call) {
+            continue;
+        }
+        if (!call.resultHash) {
+            noProgressEvidence = false;
+            break;
+        }
+        if (call.argsHash === last.argsHash) {
+            if (!firstHashA) {
+                firstHashA = call.resultHash;
+            }
+            else if (firstHashA !== call.resultHash) {
+                noProgressEvidence = false;
+                break;
+            }
+            continue;
+        }
+        if (call.argsHash === otherSignature) {
+            if (!firstHashB) {
+                firstHashB = call.resultHash;
+            }
+            else if (firstHashB !== call.resultHash) {
+                noProgressEvidence = false;
+                break;
+            }
+            continue;
+        }
+        noProgressEvidence = false;
+        break;
+    }
+    // Need repeated stable outcomes on both sides before treating ping-pong as no-progress.
+    if (!firstHashA || !firstHashB) {
+        noProgressEvidence = false;
+    }
+    return {
+        count: alternatingTailCount + 1,
+        pairedToolName: last.toolName,
+        pairedSignature: last.argsHash,
+        noProgressEvidence,
+    };
+}
+function canonicalPairKey(signatureA, signatureB) {
+    return [signatureA, signatureB].slice().sort().join("|");
+}
+/**
+ * Detect if an agent is stuck in a repetitive tool call loop.
+ * Checks if the same tool+params combination has been called excessively.
+ */
+export function detectToolCallLoop(state, toolName, params, config) {
+    const resolvedConfig = resolveLoopDetectionConfig(config);
+    if (!resolvedConfig.enabled) {
+        return { stuck: false };
+    }
+    const history = state.toolCallHistory ?? [];
+    const currentHash = hashToolCall(toolName, params);
+    const noProgress = getNoProgressStreak(history, toolName, currentHash);
+    const noProgressStreak = noProgress.count;
+    const knownPollTool = isKnownPollToolCall(toolName, params);
+    const pingPong = getPingPongStreak(history, currentHash);
+    if (noProgressStreak >= resolvedConfig.globalCircuitBreakerThreshold) {
+        log.error(`Global circuit breaker triggered: ${toolName} repeated ${noProgressStreak} times with no progress`);
+        return {
+            stuck: true,
+            level: "critical",
+            detector: "global_circuit_breaker",
+            count: noProgressStreak,
+            message: `CRITICAL: ${toolName} has repeated identical no-progress outcomes ${noProgressStreak} times. Session execution blocked by global circuit breaker to prevent runaway loops.`,
+            warningKey: `global:${toolName}:${currentHash}:${noProgress.latestResultHash ?? "none"}`,
+        };
+    }
+    if (knownPollTool &&
+        resolvedConfig.detectors.knownPollNoProgress &&
+        noProgressStreak >= resolvedConfig.criticalThreshold) {
+        log.error(`Critical polling loop detected: ${toolName} repeated ${noProgressStreak} times`);
+        return {
+            stuck: true,
+            level: "critical",
+            detector: "known_poll_no_progress",
+            count: noProgressStreak,
+            message: `CRITICAL: Called ${toolName} with identical arguments and no progress ${noProgressStreak} times. This appears to be a stuck polling loop. Session execution blocked to prevent resource waste.`,
+            warningKey: `poll:${toolName}:${currentHash}:${noProgress.latestResultHash ?? "none"}`,
+        };
+    }
+    if (knownPollTool &&
+        resolvedConfig.detectors.knownPollNoProgress &&
+        noProgressStreak >= resolvedConfig.warningThreshold) {
+        log.warn(`Polling loop warning: ${toolName} repeated ${noProgressStreak} times`);
+        return {
+            stuck: true,
+            level: "warning",
+            detector: "known_poll_no_progress",
+            count: noProgressStreak,
+            message: `WARNING: You have called ${toolName} ${noProgressStreak} times with identical arguments and no progress. Stop polling and either (1) increase wait time between checks, or (2) report the task as failed if the process is stuck.`,
+            warningKey: `poll:${toolName}:${currentHash}:${noProgress.latestResultHash ?? "none"}`,
+        };
+    }
+    const pingPongWarningKey = pingPong.pairedSignature
+        ? `pingpong:${canonicalPairKey(currentHash, pingPong.pairedSignature)}`
+        : `pingpong:${toolName}:${currentHash}`;
+    if (resolvedConfig.detectors.pingPong &&
+        pingPong.count >= resolvedConfig.criticalThreshold &&
+        pingPong.noProgressEvidence) {
+        log.error(`Critical ping-pong loop detected: alternating calls count=${pingPong.count} currentTool=${toolName}`);
+        return {
+            stuck: true,
+            level: "critical",
+            detector: "ping_pong",
+            count: pingPong.count,
+            message: `CRITICAL: You are alternating between repeated tool-call patterns (${pingPong.count} consecutive calls) with no progress. This appears to be a stuck ping-pong loop. Session execution blocked to prevent resource waste.`,
+            pairedToolName: pingPong.pairedToolName,
+            warningKey: pingPongWarningKey,
+        };
+    }
+    if (resolvedConfig.detectors.pingPong && pingPong.count >= resolvedConfig.warningThreshold) {
+        log.warn(`Ping-pong loop warning: alternating calls count=${pingPong.count} currentTool=${toolName}`);
+        return {
+            stuck: true,
+            level: "warning",
+            detector: "ping_pong",
+            count: pingPong.count,
+            message: `WARNING: You are alternating between repeated tool-call patterns (${pingPong.count} consecutive calls). This looks like a ping-pong loop; stop retrying and report the task as failed.`,
+            pairedToolName: pingPong.pairedToolName,
+            warningKey: pingPongWarningKey,
+        };
+    }
+    // Generic detector: warn-only for repeated identical calls.
+    const recentCount = history.filter((h) => h.toolName === toolName && h.argsHash === currentHash).length;
+    if (!knownPollTool &&
+        resolvedConfig.detectors.genericRepeat &&
+        recentCount >= resolvedConfig.warningThreshold) {
+        log.warn(`Loop warning: ${toolName} called ${recentCount} times with identical arguments`);
+        return {
+            stuck: true,
+            level: "warning",
+            detector: "generic_repeat",
+            count: recentCount,
+            message: `WARNING: You have called ${toolName} ${recentCount} times with identical arguments. If this is not making progress, stop retrying and report the task as failed.`,
+            warningKey: `generic:${toolName}:${currentHash}`,
+        };
+    }
+    return { stuck: false };
+}
+/**
+ * Record a tool call in the session's history for loop detection.
+ * Maintains sliding window of last N calls.
+ */
+export function recordToolCall(state, toolName, params, toolCallId, config) {
+    const resolvedConfig = resolveLoopDetectionConfig(config);
+    if (!state.toolCallHistory) {
+        state.toolCallHistory = [];
+    }
+    state.toolCallHistory.push({
+        toolName,
+        argsHash: hashToolCall(toolName, params),
+        toolCallId,
+        timestamp: Date.now(),
+    });
+    if (state.toolCallHistory.length > resolvedConfig.historySize) {
+        state.toolCallHistory.shift();
+    }
+}
+/**
+ * Record a completed tool call outcome so loop detection can identify no-progress repeats.
+ */
+export function recordToolCallOutcome(state, params) {
+    const resolvedConfig = resolveLoopDetectionConfig(params.config);
+    const resultHash = hashToolOutcome(params.toolName, params.toolParams, params.result, params.error);
+    if (!resultHash) {
+        return;
+    }
+    if (!state.toolCallHistory) {
+        state.toolCallHistory = [];
+    }
+    const argsHash = hashToolCall(params.toolName, params.toolParams);
+    let matched = false;
+    for (let i = state.toolCallHistory.length - 1; i >= 0; i -= 1) {
+        const call = state.toolCallHistory[i];
+        if (!call) {
+            continue;
+        }
+        if (params.toolCallId && call.toolCallId !== params.toolCallId) {
+            continue;
+        }
+        if (call.toolName !== params.toolName || call.argsHash !== argsHash) {
+            continue;
+        }
+        if (call.resultHash !== undefined) {
+            continue;
+        }
+        call.resultHash = resultHash;
+        matched = true;
+        break;
+    }
+    if (!matched) {
+        state.toolCallHistory.push({
+            toolName: params.toolName,
+            argsHash,
+            toolCallId: params.toolCallId,
+            resultHash,
+            timestamp: Date.now(),
+        });
+    }
+    if (state.toolCallHistory.length > resolvedConfig.historySize) {
+        state.toolCallHistory.splice(0, state.toolCallHistory.length - resolvedConfig.historySize);
+    }
+}
+/**
+ * Get current tool call statistics for a session (for debugging/monitoring).
+ */
+export function getToolCallStats(state) {
+    const history = state.toolCallHistory ?? [];
+    const patterns = new Map();
+    for (const call of history) {
+        const key = call.argsHash;
+        const existing = patterns.get(key);
+        if (existing) {
+            existing.count += 1;
+        }
+        else {
+            patterns.set(key, { toolName: call.toolName, count: 1 });
+        }
+    }
+    let mostFrequent = null;
+    for (const pattern of patterns.values()) {
+        if (!mostFrequent || pattern.count > mostFrequent.count) {
+            mostFrequent = pattern;
+        }
+    }
+    return {
+        totalCalls: history.length,
+        uniquePatterns: patterns.size,
+        mostFrequent,
+    };
+}

package/dist/auto-reply/reply/agent-runner-memory.js

@@ -8,7 +8,7 @@ import { resolveAgentIdFromSessionKey, updateSessionStoreEntry, } from "../../co
 import { logVerbose } from "../../globals.js";
 import { registerAgentRunContext } from "../../infra/agent-events.js";
 import { buildThreadingToolContext, resolveEnforceFinalTag } from "./agent-runner-utils.js";
-import { resolveMemoryFlushContextWindowTokens, resolveMemoryFlushSettings, shouldRunMemoryFlush, } from "./memory-flush.js";
+import { resolveMemoryFlushContextWindowTokens, resolveMemoryFlushPromptForRun, resolveMemoryFlushSettings, shouldRunMemoryFlush, } from "./memory-flush.js";
 import { incrementCompactionCount } from "./session-updates.js";
 export async function runMemoryFlushIfNeeded(params) {
     const memoryFlushSettings = resolveMemoryFlushSettings(params.cfg);
@@ -86,7 +86,10 @@ export async function runMemoryFlushIfNeeded(params) {
                     agentDir: params.followupRun.run.agentDir,
                     config: params.followupRun.run.config,
                     skillsSnapshot: params.followupRun.run.skillsSnapshot,
-                    prompt: memoryFlushSettings.prompt,
+                    prompt: resolveMemoryFlushPromptForRun({
+                        prompt: memoryFlushSettings.prompt,
+                        cfg: params.cfg,
+                    }),
                     extraSystemPrompt: flushSystemPrompt,
                     ownerNumbers: params.followupRun.run.ownerNumbers,
                     enforceFinalTag: resolveEnforceFinalTag(params.followupRun.run, provider),

package/dist/auto-reply/reply/memory-flush.js

@@ -1,6 +1,7 @@
 import { lookupContextTokens } from "../../agents/context.js";
 import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
 import { DEFAULT_PI_COMPACTION_RESERVE_TOKENS_FLOOR } from "../../agents/pi-settings.js";
+import { resolveCronStyleNow } from "../../agents/current-time.js";
 import { SILENT_REPLY_TOKEN } from "../tokens.js";
 export const DEFAULT_MEMORY_FLUSH_SOFT_TOKENS = 4000;
 export const DEFAULT_MEMORY_FLUSH_PROMPT = [
@@ -13,6 +14,34 @@ export const DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT = [
     "The session is near auto-compaction; capture durable memories to disk.",
     `You may reply, but usually ${SILENT_REPLY_TOKEN} is correct.`,
 ].join(" ");
+function formatDateStampInTimezone(nowMs, timezone) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).formatToParts(new Date(nowMs));
+    const year = parts.find((part) => part.type === "year")?.value;
+    const month = parts.find((part) => part.type === "month")?.value;
+    const day = parts.find((part) => part.type === "day")?.value;
+    if (year && month && day) {
+        return `${year}-${month}-${day}`;
+    }
+    return new Date(nowMs).toISOString().slice(0, 10);
+}
+export function resolveMemoryFlushPromptForRun(params) {
+    const nowMs = Number.isFinite(params.nowMs) ? params.nowMs : Date.now();
+    const { userTimezone, timeLine } = resolveCronStyleNow(params.cfg ?? {}, nowMs);
+    const dateStamp = formatDateStampInTimezone(nowMs, userTimezone);
+    const withDate = params.prompt.replaceAll("YYYY-MM-DD", dateStamp).trimEnd();
+    if (!withDate) {
+        return timeLine;
+    }
+    if (withDate.includes("Current time:")) {
+        return withDate;
+    }
+    return `${withDate}\n${timeLine}`;
+}
 const normalizeNonNegativeInt = (value) => {
     if (typeof value !== "number" || !Number.isFinite(value))
         return null;

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.124.22101",
-  "commit": "6cc4c70b7d6ace6795607a2fa5af148ad9d298b1",
-  "builtAt": "2026-02-21T09:58:56.755Z"
+  "version": "0.124.22103",
+  "commit": "26c6012e4c975e80fd2451500e42860963ab9769",
+  "builtAt": "2026-02-21T12:43:23.274Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-1ff2bc629414e454a316b175cdaff86a5e8e609702bcbf03b78830051ea3bb12
+2dcfe6aa8af2461f166cc45178dffe3f6e8b3ab9a4585db2acea8c3ebff7e802

package/dist/logging/diagnostic-session-state.js

@@ -0,0 +1,75 @@
+export const diagnosticSessionStates = new Map();
+const SESSION_STATE_TTL_MS = 30 * 60 * 1000;
+const SESSION_STATE_PRUNE_INTERVAL_MS = 60 * 1000;
+const SESSION_STATE_MAX_ENTRIES = 2000;
+let lastSessionPruneAt = 0;
+export function pruneDiagnosticSessionStates(now = Date.now(), force = false) {
+    const shouldPruneForSize = diagnosticSessionStates.size > SESSION_STATE_MAX_ENTRIES;
+    if (!force && !shouldPruneForSize && now - lastSessionPruneAt < SESSION_STATE_PRUNE_INTERVAL_MS) {
+        return;
+    }
+    lastSessionPruneAt = now;
+    for (const [key, state] of diagnosticSessionStates.entries()) {
+        const ageMs = now - state.lastActivity;
+        const isIdle = state.state === "idle";
+        if (isIdle && state.queueDepth <= 0 && ageMs > SESSION_STATE_TTL_MS) {
+            diagnosticSessionStates.delete(key);
+        }
+    }
+    if (diagnosticSessionStates.size <= SESSION_STATE_MAX_ENTRIES) {
+        return;
+    }
+    const excess = diagnosticSessionStates.size - SESSION_STATE_MAX_ENTRIES;
+    const ordered = Array.from(diagnosticSessionStates.entries())
+        .slice()
+        .sort((a, b) => a[1].lastActivity - b[1].lastActivity);
+    for (let i = 0; i < excess; i += 1) {
+        const key = ordered[i]?.[0];
+        if (!key) {
+            break;
+        }
+        diagnosticSessionStates.delete(key);
+    }
+}
+function resolveSessionKey({ sessionKey, sessionId }) {
+    return sessionKey ?? sessionId ?? "unknown";
+}
+function findStateBySessionId(sessionId) {
+    for (const state of diagnosticSessionStates.values()) {
+        if (state.sessionId === sessionId) {
+            return state;
+        }
+    }
+    return undefined;
+}
+export function getDiagnosticSessionState(ref) {
+    pruneDiagnosticSessionStates();
+    const key = resolveSessionKey(ref);
+    const existing = diagnosticSessionStates.get(key) ?? (ref.sessionId && findStateBySessionId(ref.sessionId));
+    if (existing) {
+        if (ref.sessionId) {
+            existing.sessionId = ref.sessionId;
+        }
+        if (ref.sessionKey) {
+            existing.sessionKey = ref.sessionKey;
+        }
+        return existing;
+    }
+    const created = {
+        sessionId: ref.sessionId,
+        sessionKey: ref.sessionKey,
+        lastActivity: Date.now(),
+        state: "idle",
+        queueDepth: 0,
+    };
+    diagnosticSessionStates.set(key, created);
+    pruneDiagnosticSessionStates(Date.now(), true);
+    return created;
+}
+export function getDiagnosticSessionStateCountForTest() {
+    return diagnosticSessionStates.size;
+}
+export function resetDiagnosticSessionStateForTest() {
+    diagnosticSessionStates.clear();
+    lastSessionPruneAt = 0;
+}

package/dist/logging/diagnostic.js

@@ -233,4 +233,26 @@ export function stopDiagnosticHeartbeat() {
         heartbeatInterval = null;
     }
 }
+export function logToolLoopAction(params) {
+    const payload = `tool loop: sessionId=${params.sessionId ?? "unknown"} sessionKey=${params.sessionKey ?? "unknown"} tool=${params.toolName} level=${params.level} action=${params.action} detector=${params.detector} count=${params.count}${params.pairedToolName ? ` pairedTool=${params.pairedToolName}` : ""} message="${params.message}"`;
+    if (params.level === "critical") {
+        diag.error(payload);
+    }
+    else {
+        diag.warn(payload);
+    }
+    emitDiagnosticEvent({
+        type: "tool.loop",
+        sessionId: params.sessionId,
+        sessionKey: params.sessionKey,
+        toolName: params.toolName,
+        level: params.level,
+        action: params.action,
+        detector: params.detector,
+        count: params.count,
+        message: params.message,
+        pairedToolName: params.pairedToolName,
+    });
+    markActivity();
+}
 export { diag as diagnosticLogger };

package/dist/memory/hybrid.js

@@ -1,6 +1,6 @@
 export function buildFtsQuery(raw) {
     const tokens = raw
-        .match(/[A-Za-z0-9_]+/g)
+        .match(/[\p{L}\p{N}_]+/gu)
         ?.map((t) => t.trim())
         .filter(Boolean) ?? [];
     if (tokens.length === 0)

package/dist/utils.js

@@ -243,5 +243,14 @@ export function formatTerminalLink(label, url, opts) {
     }
     return `\u001b]8;;${safeUrl}\u0007${safeLabel}\u001b]8;;\u0007`;
 }
+/**
+ * Strict plain-object guard (excludes arrays and host objects).
+ */
+export function isPlainObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.prototype.toString.call(value) === "[object Object]");
+}
 // Configuration root; can be overridden via CLAWDBOT_STATE_DIR.
 export const CONFIG_DIR = resolveConfigDir();