screenhand 0.2.0 → 0.3.1

package/dist/src/learning/topology-policy.js

@@ -0,0 +1,90 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * TopologyPolicy — learns which navigation edges are reliable per app.
+ *
+ * Persisted to `topology.jsonl`. Each entry tracks success/fail counts
+ * for a specific bundleId×fromNode×action×toNode quad, scored with
+ * Bayesian averaging.
+ *
+ * Used alongside the AppMap to determine which navigation paths
+ * through an application are verified and reliable.
+ */
+export class TopologyPolicy {
+    entries = new Map();
+    priorStrength;
+    constructor(priorStrength = 2) {
+        this.priorStrength = priorStrength;
+    }
+    /**
+     * Record a navigation edge outcome (success/failure for an app).
+     */
+    record(outcome) {
+        const key = `${outcome.bundleId}::${outcome.fromNode}::${outcome.action}::${outcome.toNode}`;
+        let entry = this.entries.get(key);
+        if (!entry) {
+            entry = {
+                key,
+                bundleId: outcome.bundleId,
+                fromNode: outcome.fromNode,
+                action: outcome.action,
+                toNode: outcome.toNode,
+                successCount: 0,
+                failCount: 0,
+                score: 0.5,
+                lastUsed: new Date().toISOString(),
+            };
+            this.entries.set(key, entry);
+        }
+        if (outcome.success) {
+            entry.successCount++;
+        }
+        else {
+            entry.failCount++;
+        }
+        entry.score = this.bayesianScore(entry.successCount, entry.failCount);
+        entry.lastUsed = new Date().toISOString();
+    }
+    /**
+     * Query all navigation edges for a given app, sorted by score descending.
+     * Optionally filter by source node.
+     */
+    query(bundleId, fromNode) {
+        const results = [];
+        for (const entry of this.entries.values()) {
+            if (entry.bundleId !== bundleId)
+                continue;
+            if (fromNode && entry.fromNode !== fromNode)
+                continue;
+            results.push(entry);
+        }
+        return results.sort((a, b) => b.score - a.score);
+    }
+    /**
+     * Get the best navigation edge from a given node, or null if insufficient data.
+     */
+    recommend(bundleId, fromNode, minSamples = 3) {
+        const candidates = this.query(bundleId, fromNode);
+        for (const entry of candidates) {
+            if (entry.successCount + entry.failCount >= minSamples && entry.score > 0.5) {
+                return entry;
+            }
+        }
+        return null;
+    }
+    clear() {
+        this.entries.clear();
+    }
+    getAllEntries() {
+        return [...this.entries.values()];
+    }
+    loadEntries(entries) {
+        for (const entry of entries) {
+            this.entries.set(entry.key, { ...entry });
+        }
+    }
+    bayesianScore(successes, failures) {
+        return ((successes + this.priorStrength) /
+            (successes + failures + 2 * this.priorStrength));
+    }
+}

package/dist/src/learning/types.js

@@ -0,0 +1,9 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+export const DEFAULT_LEARNING_CONFIG = {
+    dataDir: "",
+    minSamplesForConfidence: 5,
+    priorStrength: 2,
+    maxEntriesPerFile: 5000,
+    maxTimingSamples: 100,
+};

package/dist/src/logging/timeline-logger.js

@@ -29,7 +29,10 @@ export class TimelineLogger {
     }
     finish(telemetry, status) {
         const finishedAt = new Date().toISOString();
-        const totalMs = new Date(finishedAt).getTime() - new Date(telemetry.startedAt).getTime();
+        const startTime = new Date(telemetry.startedAt).getTime();
+        const totalMs = Number.isFinite(startTime)
+            ? new Date(finishedAt).getTime() - startTime
+            : 0;
         const finalized = {
             ...telemetry,
             finishedAt,

package/dist/src/memory/playbook-seeds.js

@@ -0,0 +1,200 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+// This file is part of ScreenHand.
+/**
+ * Playbook Seeds — converts playbook reference knowledge into memory-compatible formats.
+ *
+ * Reads all playbooks from disk and extracts:
+ *   - errors[]       → ErrorPattern[]  (for quickErrorCheck auto-warnings)
+ *   - flows{}        → Learning[]      (for pattern recall)
+ *   - selectors{}    → Learning[]      (for verified selector patterns)
+ *   - policyNotes{}  → Learning[]      (for rate limits and safety)
+ *
+ * Called once during MemoryStore.init() to seed the memory system with
+ * months of team-curated platform knowledge.
+ */
+import fs from "node:fs";
+import path from "node:path";
+// ── Tool name inference from error/solution text ──
+const TOOL_KEYWORDS = {
+    browser_click: ["click", "el.click", ".click()", "button"],
+    browser_human_click: ["human_click", "dispatchMouseEvent", "CDP Input"],
+    browser_fill_form: ["fill_form", "browser_fill_form", "form"],
+    browser_type: ["browser_type", "type into", "typing"],
+    browser_js: ["browser_js", "evaluate", "script", "execCommand"],
+    browser_navigate: ["navigate", "navigation", "url"],
+    browser_dom: ["querySelector", "selector", "DOM"],
+    browser_wait: ["wait", "timeout", "load"],
+    click: ["native click", "coordinates", "screen click"],
+    type_text: ["type_text", "native typing"],
+    scroll: ["scroll"],
+};
+function inferTool(text) {
+    const lower = text.toLowerCase();
+    for (const [tool, keywords] of Object.entries(TOOL_KEYWORDS)) {
+        if (keywords.some(kw => lower.includes(kw.toLowerCase())))
+            return tool;
+    }
+    return "browser_click"; // default — most errors are click-related
+}
+// ── Main seed functions ──
+/**
+ * Read all playbooks from a directory and extract error patterns.
+ * These get loaded into memory's errorsCache so quickErrorCheck() catches them.
+ */
+export function seedErrorsFromPlaybooks(playbooksDir) {
+    const playbooks = loadPlaybooks(playbooksDir);
+    const errors = [];
+    const seen = new Set(); // deduplicate by error text
+    for (const pb of playbooks) {
+        const platform = pb.platform ?? pb.id ?? "unknown";
+        // Extract from errors[]
+        if (pb.errors) {
+            for (const err of pb.errors) {
+                const key = `${platform}::${err.error}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                errors.push({
+                    id: `pb_err_${platform}_${errors.length}`,
+                    tool: inferTool(`${err.error} ${err.context} ${err.solution}`),
+                    params: { _source: "playbook", _platform: platform },
+                    error: `[${platform}] ${err.error}`,
+                    resolution: err.solution,
+                    occurrences: err.severity === "high" ? 10 : err.severity === "medium" ? 5 : 2,
+                    lastSeen: new Date().toISOString(),
+                });
+            }
+        }
+        // Extract from flows — tips and why fields often contain error knowledge
+        if (pb.flows) {
+            for (const [flowName, flow] of Object.entries(pb.flows)) {
+                if (flow.why && flow.why.includes("doesn't") || flow.why?.includes("don't") || flow.why?.includes("NOT")) {
+                    const key = `${platform}::${flowName}::why`;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    errors.push({
+                        id: `pb_err_${platform}_flow_${errors.length}`,
+                        tool: inferTool(flow.why ?? ""),
+                        params: { _source: "playbook", _platform: platform, _flow: flowName },
+                        error: `[${platform}/${flowName}] ${flow.why.slice(0, 200)}`,
+                        resolution: flow.steps?.join(" → ") ?? null,
+                        occurrences: 5,
+                        lastSeen: new Date().toISOString(),
+                    });
+                }
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Read all playbooks and extract learnings (selectors, patterns, policy notes).
+ * These get loaded into memory's learningsCache so queryPatterns() finds them.
+ */
+export function seedLearningsFromPlaybooks(playbooksDir) {
+    const playbooks = loadPlaybooks(playbooksDir);
+    const learnings = [];
+    for (const pb of playbooks) {
+        const platform = pb.platform ?? pb.id ?? "unknown";
+        const reliability = (pb.successCount ?? 0) + (pb.failCount ?? 0) > 0
+            ? (pb.successCount ?? 0) / ((pb.successCount ?? 0) + (pb.failCount ?? 0))
+            : 0.7;
+        // Selectors → learnings (verified working CSS selectors)
+        if (pb.selectors) {
+            for (const [group, sels] of Object.entries(pb.selectors)) {
+                for (const [name, selector] of Object.entries(sels)) {
+                    // Skip notes/annotations (keys starting with _)
+                    if (name.startsWith("_"))
+                        continue;
+                    learnings.push({
+                        scope: `chrome/${platform}`,
+                        pattern: `${group}.${name}: ${selector}`,
+                        method: "cdp",
+                        confidence: reliability,
+                        successCount: Math.max(1, Math.round(reliability * 10)),
+                        failCount: Math.round((1 - reliability) * 10),
+                        lastSeen: new Date().toISOString(),
+                        fix: null,
+                    });
+                }
+            }
+        }
+        // Flow selectors → learnings
+        if (pb.flows) {
+            for (const [flowName, flow] of Object.entries(pb.flows)) {
+                if (flow.selectors) {
+                    for (const [name, selector] of Object.entries(flow.selectors)) {
+                        learnings.push({
+                            scope: `chrome/${platform}/${flowName}`,
+                            pattern: `${name}: ${selector}`,
+                            method: "cdp",
+                            confidence: reliability,
+                            successCount: Math.max(1, Math.round(reliability * 10)),
+                            failCount: Math.round((1 - reliability) * 10),
+                            lastSeen: new Date().toISOString(),
+                            fix: null,
+                        });
+                    }
+                }
+            }
+        }
+        // Policy notes → learnings (rate limits, safety rules)
+        if (pb.policyNotes) {
+            for (const [category, notes] of Object.entries(pb.policyNotes)) {
+                for (const note of notes) {
+                    learnings.push({
+                        scope: `policy/${platform}`,
+                        pattern: `[${category}] ${note}`,
+                        method: "cdp",
+                        confidence: 1.0,
+                        successCount: 10,
+                        failCount: 0,
+                        lastSeen: new Date().toISOString(),
+                        fix: null,
+                    });
+                }
+            }
+        }
+        // Detection expressions → learnings
+        if (pb.detection) {
+            for (const [name, expr] of Object.entries(pb.detection)) {
+                learnings.push({
+                    scope: `chrome/${platform}/detection`,
+                    pattern: `${name}: ${expr}`,
+                    method: "cdp",
+                    confidence: reliability,
+                    successCount: Math.max(1, Math.round(reliability * 10)),
+                    failCount: 0,
+                    lastSeen: new Date().toISOString(),
+                    fix: null,
+                });
+            }
+        }
+    }
+    return learnings;
+}
+// ── Helpers ──
+function loadPlaybooks(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    const files = fs.readdirSync(dir).filter(f => f.endsWith(".json"));
+    const playbooks = [];
+    for (const file of files) {
+        try {
+            const raw = JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8"));
+            // Ensure it has an id
+            if (!raw.id)
+                raw.id = file.replace(".json", "");
+            if (!raw.platform)
+                raw.platform = raw.id;
+            playbooks.push(raw);
+        }
+        catch {
+            // Skip unparseable files
+        }
+    }
+    return playbooks;
+}

package/dist/src/memory/recall.js

@@ -24,7 +24,7 @@ export class RecallEngine {
      * Find strategies matching a task description (~0ms, in-memory).
      * Strategies with high fail rates are penalized.
      */
-    recallStrategies(query, limit = 5) {
+    recallStrategies(query, limit = 5, currentBundleId) {
         const strategies = this.store.readStrategies();
         if (strategies.length === 0)
             return [];
@@ -32,13 +32,13 @@ export class RecallEngine {
         if (queryTokens.length === 0)
             return [];
         const scored = strategies.map((s) => {
+            // Only match against task description, tags, and tool names.
+            // Step params (JS code, URLs, selectors) contain too many generic words
+            // and cause false positives against unrelated strategies.
             const targetTokens = new Set([
                 ...tokenize(s.task),
                 ...s.tags,
                 ...s.steps.map((step) => step.tool),
-                ...s.steps.flatMap((step) => Object.values(step.params)
-                    .filter((v) => typeof v === "string")
-                    .flatMap(tokenize)),
             ]);
             let matches = 0;
             for (const qt of queryTokens) {
@@ -51,7 +51,7 @@ export class RecallEngine {
             }
             const relevance = matches / queryTokens.length;
             const ageMs = Date.now() - new Date(s.lastUsed).getTime();
-            const ageDays = ageMs / (1000 * 60 * 60 * 24);
+            const ageDays = Number.isFinite(ageMs) ? ageMs / (1000 * 60 * 60 * 24) : 0;
             const recency = Math.max(0.5, 1.0 - ageDays / 365);
             const successBoost = 1 + Math.log2(Math.max(1, s.successCount)) * 0.1;
             // Penalty for strategies that have failed — reduces score proportionally
@@ -60,7 +60,32 @@ export class RecallEngine {
             const reliabilityPenalty = totalAttempts > 0
                 ? s.successCount / totalAttempts
                 : 1;
-            const score = relevance * recency * successBoost * reliabilityPenalty;
+            // App-context filtering: penalize strategies whose steps target a different app
+            let appContextFactor = 1.0;
+            if (currentBundleId) {
+                const stepsStr = s.steps.map((step) => JSON.stringify(step.params)).join(" ").toLowerCase();
+                const taskStr = s.task.toLowerCase();
+                const bundleLower = currentBundleId.toLowerCase();
+                // Extract app name from bundleId (e.g. "com.apple.Safari" → "safari")
+                const appName = bundleLower.split(".").pop() ?? "";
+                const mentionsCurrentApp = taskStr.includes(bundleLower) || taskStr.includes(appName)
+                    || stepsStr.includes(bundleLower);
+                // Check if strategy targets a DIFFERENT app via focus/launch steps
+                const hasFocusStep = s.steps.some((step) => (step.tool === "focus" || step.tool === "launch") &&
+                    step.params && "bundleId" in step.params &&
+                    typeof step.params.bundleId === "string" &&
+                    step.params.bundleId.toLowerCase() !== bundleLower);
+                if (hasFocusStep && !mentionsCurrentApp) {
+                    appContextFactor = 0.1; // Heavy penalty for wrong-app strategies
+                }
+                else if (mentionsCurrentApp) {
+                    appContextFactor = 1.5; // Boost for matching strategies
+                }
+            }
+            // Require at least 50% token overlap to be considered relevant
+            if (relevance < 0.5)
+                return { ...s, score: 0 };
+            const score = relevance * recency * successBoost * reliabilityPenalty * appContextFactor;
             return { ...s, score };
         });
         return scored
@@ -103,9 +128,13 @@ export class RecallEngine {
      * Tries fingerprint prefix match first (O(1)), then falls back to scan.
      * Skips unreliable strategies (failCount > successCount).
      */
-    quickStrategyHint(recentTools) {
+    quickStrategyHint(recentTools, currentBundleId) {
         if (recentTools.length === 0)
             return null;
+        // Require at least 2 tools in the sequence to reduce false positives
+        // from single-tool matches (e.g. just "focus" matching every strategy)
+        if (recentTools.length < 2)
+            return null;
         const strategies = this.store.readStrategies();
         for (const s of strategies) {
             if (s.steps.length <= recentTools.length)
@@ -114,6 +143,18 @@ export class RecallEngine {
             const failCount = s.failCount ?? 0;
             if (failCount > s.successCount)
                 continue;
+            // If we know the current app, prefer strategies that mention it
+            // and skip strategies clearly for a different app
+            if (currentBundleId) {
+                const taskLower = s.task.toLowerCase();
+                const bundleLower = currentBundleId.toLowerCase();
+                // Extract app name from bundleId (e.g. "com.apple.Safari" → "safari")
+                const appName = bundleLower.split(".").pop() ?? "";
+                const mentionsCurrentApp = taskLower.includes(appName) || taskLower.includes(bundleLower);
+                const mentionsOtherApp = !mentionsCurrentApp && /com\.\w+\.\w+/.test(s.task);
+                if (mentionsOtherApp)
+                    continue; // strategy is for a different app
+            }
             const strategyToolPrefix = s.steps.slice(0, recentTools.length).map((st) => st.tool);
             const matches = recentTools.every((t, i) => t === strategyToolPrefix[i]);
             if (matches) {
@@ -144,11 +185,22 @@ export class RecallEngine {
     }
 }
 /** Tokenize a string into lowercase keywords (3+ chars) */
+/** Common automation verbs/nouns that match almost any strategy — filter them out */
+const RECALL_STOPWORDS = new Set([
+    "open", "close", "click", "set", "get", "the", "and", "for", "from",
+    "into", "with", "then", "this", "that", "use", "run", "start", "stop",
+    "new", "add", "app", "settings", "window", "button", "text", "page",
+    "file", "menu", "tab", "navigate", "type", "select", "find", "wait",
+    "send", "save", "copy", "paste", "delete", "create", "edit", "view",
+    "show", "hide", "move", "drag", "drop", "enter", "press", "about",
+    "input", "form", "link", "image", "video", "upload", "download",
+    "first", "last", "next", "take", "result", "search",
+]);
 function tokenize(text) {
     return text
         .toLowerCase()
         .split(/[\W_]+/)
-        .filter((w) => w.length >= 3);
+        .filter((w) => w.length >= 2 && !RECALL_STOPWORDS.has(w));
 }
 /** Simple string similarity: shared character bigrams / total bigrams */
 function stringSimilarity(a, b) {

package/dist/src/memory/service.js

@@ -29,6 +29,7 @@ import { writeFileAtomicSync } from "../util/atomic-write.js";
 import { MemoryStore } from "./store.js";
 import { SessionTracker } from "./session.js";
 import { RecallEngine } from "./recall.js";
+import { seedLearningsFromPlaybooks } from "./playbook-seeds.js";
 // ── Defaults ─────────────────────────────────────
 const DEFAULT_POLICY = {
     maxConsecutiveErrors: 5,
@@ -90,6 +91,26 @@ export class MemoryService {
         this.ensureMemDir();
         // Load learnings
         this.learningsCache = this.readJsonlSafe("learnings.jsonl");
+        // Seed learnings from playbooks — selectors, detection, policy notes.
+        // These have scope prefixes like "chrome/figma" so they merge cleanly
+        // with runtime-discovered learnings without duplicating.
+        const playbooksDir = path.join(this.baseDir, "references");
+        const pbLearnings = seedLearningsFromPlaybooks(playbooksDir);
+        if (pbLearnings.length > 0) {
+            const existingKeys = new Set(this.learningsCache.map(l => `${l.scope}::${l.pattern}::${l.method}`));
+            let added = 0;
+            for (const pl of pbLearnings) {
+                const key = `${pl.scope}::${pl.pattern}::${pl.method}`;
+                if (!existingKeys.has(key)) {
+                    this.learningsCache.push({
+                        id: `pb_lrn_${added}`,
+                        ...pl,
+                    });
+                    existingKeys.add(key);
+                    added++;
+                }
+            }
+        }
         // Load existing snapshot if present (to restore mission/policy across restarts)
         const snapPath = this.filePath("state.json");
         if (fs.existsSync(snapPath)) {
@@ -285,17 +306,17 @@ export class MemoryService {
     queryErrors(tool) {
         return this.recall.recallErrors(tool);
     }
-    /** Fuzzy-match strategies by query string. */
-    recallStrategies(query, limit) {
-        return this.recall.recallStrategies(query, limit);
+    /** Fuzzy-match strategies by query string. Optionally filter by current app. */
+    recallStrategies(query, limit, currentBundleId) {
+        return this.recall.recallStrategies(query, limit, currentBundleId);
     }
     /** Quick error check for interceptor (~0ms). */
     quickErrorCheck(tool) {
         return this.recall.quickErrorCheck(tool);
     }
     /** Quick strategy hint for interceptor (~0ms). */
-    quickStrategyHint(recentTools) {
-        return this.recall.quickStrategyHint(recentTools);
+    quickStrategyHint(recentTools, currentBundleId) {
+        return this.recall.quickStrategyHint(recentTools, currentBundleId);
     }
     /** Record strategy outcome for feedback loop. */
     recordStrategyOutcome(fingerprint, success) {
@@ -397,6 +418,10 @@ export class MemoryService {
             return [];
         let text;
         try {
+            // Guard against oversized files (same 10MB limit as LearningEngine)
+            const stat = fs.statSync(fp);
+            if (stat.size > 10 * 1024 * 1024)
+                return [];
             text = fs.readFileSync(fp, "utf-8").trim();
         }
         catch {

package/dist/src/memory/store.js

@@ -26,7 +26,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import { writeFileAtomicSync } from "../util/atomic-write.js";
+import { redactPII } from "../util/sanitize.js";
 import { SEED_STRATEGIES } from "./seeds.js";
+import { seedErrorsFromPlaybooks } from "./playbook-seeds.js";
 const MAX_ACTION_FILE_BYTES = 10 * 1024 * 1024; // 10 MB
 const MAX_STRATEGIES = 500;
 const MAX_ERRORS = 200;
@@ -52,7 +54,9 @@ export class MemoryStore {
     // Global flag — only register exit handlers once across all instances
     static exitHandlerRegistered = false;
     static activeInstance = null;
+    baseDir;
     constructor(baseDir) {
+        this.baseDir = baseDir;
         this.dir = path.join(baseDir, ".screenhand", "memory");
         this.lockPath = path.join(this.dir, ".lock");
     }
@@ -70,11 +74,23 @@ export class MemoryStore {
         if (this.strategiesCache.length === 0 && isFirstBoot) {
             for (const s of SEED_STRATEGIES)
                 this.strategiesCache.push(s);
-            this.writeLinesSync("strategies.jsonl", this.strategiesCache);
+            this.writeStrategiesRedacted();
         }
         this.enforceStrategyLimit();
         this.rebuildFingerprintIndex();
         this.errorsCache = this.readLinesSafe("errors.jsonl");
+        // Seed errors from playbooks — merge curated platform knowledge into memory.
+        // Uses pb_err_ prefix IDs so we can identify and refresh them on each boot.
+        const playbooksDir = path.join(this.baseDir, "references");
+        const pbErrors = seedErrorsFromPlaybooks(playbooksDir);
+        if (pbErrors.length > 0) {
+            // Remove stale playbook-seeded errors (they'll be re-added with fresh data)
+            this.errorsCache = this.errorsCache.filter(e => !e.id.startsWith("pb_err_"));
+            // Merge fresh playbook errors
+            for (const e of pbErrors) {
+                this.errorsCache.push(e);
+            }
+        }
         this.enforceErrorLimit();
         // Build action stats without caching all entries
         const actions = this.readLinesSafe("actions.jsonl");
@@ -246,8 +262,9 @@ export class MemoryStore {
         if (!this.hasLock)
             return;
         this.rotateActionsIfNeeded();
-        // Buffer the write
-        this.pendingActionWrites.push(JSON.stringify(entry) + "\n");
+        // S75 Option C: Redact PII before persisting to disk (not in live responses)
+        const redacted = { ...entry, result: entry.result ? redactPII(entry.result) : entry.result };
+        this.pendingActionWrites.push(JSON.stringify(redacted) + "\n");
         // Schedule batch flush (debounced 100ms)
         if (!this.flushTimer) {
             this.flushTimer = setTimeout(() => {
@@ -321,7 +338,19 @@ export class MemoryStore {
                 this.rebuildFingerprintIndex();
             }
         }
-        this.writeLinesSync("strategies.jsonl", this.strategiesCache);
+        this.writeStrategiesRedacted();
+    }
+    /** S75 Option C: Redact PII from strategies before any disk write */
+    writeStrategiesRedacted() {
+        const redacted = this.strategiesCache.map(s => ({
+            ...s,
+            task: redactPII(s.task),
+            steps: s.steps.map(st => ({
+                ...st,
+                params: Object.fromEntries(Object.entries(st.params).map(([k, v]) => [k, typeof v === "string" ? redactPII(v) : v])),
+            })),
+        }));
+        this.writeLinesSync("strategies.jsonl", redacted);
     }
     /** O(1) exact lookup by tool sequence fingerprint */
     lookupByFingerprint(fingerprint) {
@@ -339,7 +368,7 @@ export class MemoryStore {
         else {
             strategy.failCount = (strategy.failCount ?? 0) + 1;
         }
-        this.writeLinesSync("strategies.jsonl", this.strategiesCache);
+        this.writeStrategiesRedacted();
     }
     /** Read from cache — ~0ms */
     readStrategies() {