@remnic/core 9.65.6 → 9.65.8

package/src/orchestration/maintenance.ts

@@ -51,6 +51,7 @@ import {
   graphEdgeDecayCadenceToCronExpr,
 } from "../maintenance/memory-governance-cron.js";
 import { rebuildMemoryLifecycleLedger } from "../maintenance/rebuild-memory-lifecycle-ledger.js";
+import { resolveDaySummaryCronModel } from "../maintenance/day-summary-cron.js";
 import {
   createProjectionRebuildScheduleState,
   maybeRebuildMemoryProjectionScheduled,
@@ -61,6 +62,7 @@ import {
   type LifecyclePendingIo,
 } from "../storage/memory-lifecycle-ledger-access.js";
 import { STATE_FILE_MAX_DECRYPT_BYTES } from "../storage/secure-line-reader.js";
+import { startLocationAutoSync, type LocationAutoSyncHandle } from "../location/scheduler.js";
 import { ActivitySyncRegistrar } from "../activity/sync-registration.js";
 import type { ActivitySyncRunSummary } from "../activity/runner.js";
 import { resolveHomeDir } from "../runtime/env.js";
@@ -152,6 +154,10 @@ export class MaintenanceScheduler {
   // ── Activity (screen-capture) sync scheduler (issue #1900) ──
   // The full arm/re-arm/teardown lifecycle lives in ActivitySyncRegistrar.
   private readonly activityRegistrar: ActivitySyncRegistrar;
+  // ── Location day-sync scheduler (issue #2047) — master default-off; the
+  // timer + lifecycle contract lives in location/scheduler.ts.
+  private locationAutoSync: LocationAutoSyncHandle | null = null;
+
 
   constructor(private readonly deps: MaintenanceSchedulerDeps) {
     this.activityRegistrar = new ActivitySyncRegistrar({
@@ -226,6 +232,18 @@ export class MaintenanceScheduler {
     // master default-off. The registrar owns the arm/re-arm/teardown contract
     // (stop-prior, abort/teardown guards, secure-store refusal, retry latch).
     await this.activityRegistrar.register(signal);
+    // Location day sync (issue #2047): same deferred lifecycle as activity;
+    // ticks run the SAME shared runner as the CLI/MCP/HTTP surfaces.
+    if (
+      !signal.aborted &&
+      this.deps.config.location.enabled &&
+      this.deps.config.location.sources.some((source) => source.enabled)
+    ) {
+      this.locationAutoSync = startLocationAutoSync({
+        config: this.deps.config.location,
+        memoryDir: this.deps.config.memoryDir,
+      });
+    }
   }
 
   async autoRegisterDaySummaryCron(): Promise<void> {
@@ -238,36 +256,7 @@ export class MaintenanceScheduler {
         return;
       }
 
-      // Resolve an OpenClaw cron-routing model only in gateway mode. In plugin
-      // mode, summaryModel is a direct-client model id for Remnic's own LLM
-      // calls and may be unroutable as an OpenClaw agentTurn model.
-      const rawSummaryModel = this.deps.config.summaryModel;
-      const taskPrimary = this.deps.config.taskModelChain?.primary;
-      const isGateway = this.deps.config.modelSource === "gateway";
-      const model = isGateway ? (rawSummaryModel || taskPrimary || undefined) : undefined;
-      // Attach task-chain fallbacks only when the model matches the task-chain
-      // primary. If summaryModel is a distinct override, its fallbacks would
-      // be unrelated to the task chain. Also append gateway default models as
-      // tail fallbacks (de-duped) so a task-chain outage doesn't stop the cron
-      // before reaching the gateway default chain. Mirrors hourly cron pattern.
-      const fallbacks: string[] = [];
-      if (model && taskPrimary && model === taskPrimary) {
-        const seen = new Set<string>(model ? [model] : []);
-        const addUnique = (value: string | undefined) => {
-          if (typeof value !== "string") return;
-          const trimmed = value.trim();
-          if (trimmed.length > 0 && !seen.has(trimmed)) {
-            seen.add(trimmed);
-            fallbacks.push(trimmed);
-          }
-        };
-        for (const fb of this.deps.config.taskModelChain?.fallbacks ?? []) addUnique(fb);
-        const gwDefaults = this.deps.config.gatewayConfig?.agents?.defaults?.model;
-        addUnique(gwDefaults?.primary);
-        if (Array.isArray(gwDefaults?.fallbacks)) {
-          for (const fb of gwDefaults.fallbacks) addUnique(fb);
-        }
-      }
+      const { model, fallbacks } = resolveDaySummaryCronModel(this.deps.config);
 
       const timezone =
         this.deps.config.daySummaryTimezone ||
@@ -1183,12 +1172,15 @@ export class MaintenanceScheduler {
     // re-arm QMD maintenance) and aborts+drains the sync. Capture its drain and
     // await it last so the rest of teardown runs while the aborted tick unwinds.
     const activityDrain = this.activityRegistrar.dispose();
+    const locationDrain = this.locationAutoSync?.stop() ?? Promise.resolve();
+    this.locationAutoSync = null;
     if (this.qmdMaintenanceTimer) {
       clearTimeout(this.qmdMaintenanceTimer);
       this.qmdMaintenanceTimer = null;
     }
     this.qmdMaintenancePending = false;
     await activityDrain;
+    await locationDrain;
     // Belt-and-suspenders: clear anything a late tick armed before the latch.
     if (this.qmdMaintenanceTimer) {
       clearTimeout(this.qmdMaintenanceTimer);

package/src/storage/context-transform-ledger.ts

@@ -0,0 +1,39 @@
+import type { ContextTransformTelemetryRecord } from "../active-context-transform.js";
+import { readContextTransformRecordRowsFromLines, readMaybeEncryptedLines } from "./secure-line-reader.js";
+
+export interface ContextTransformLedgerHost {
+  memoryActionsPath: string;
+  ensureDirectories(): Promise<void>;
+  appendStorageSecureFile(path: string, payload: string): Promise<void>;
+  readStorageSecureFile(path: string): Promise<string>;
+}
+
+export async function appendContextTransformRecords(
+  host: ContextTransformLedgerHost,
+  records: ContextTransformTelemetryRecord[],
+): Promise<number> {
+  if (records.length === 0) return 0;
+  await host.ensureDirectories();
+  await host.appendStorageSecureFile(
+    host.memoryActionsPath,
+    records.map((record) => `${JSON.stringify(record)}\n`).join(""),
+  );
+  return records.length;
+}
+
+export async function readContextTransformRecords(
+  host: ContextTransformLedgerHost,
+  limit = 200,
+): Promise<ContextTransformTelemetryRecord[]> {
+  const cappedLimit = Math.max(0, Math.floor(limit));
+  if (cappedLimit === 0 || Number.isNaN(cappedLimit)) return [];
+  try {
+    const rows = await readContextTransformRecordRowsFromLines(
+      readMaybeEncryptedLines(host.memoryActionsPath, () => host.readStorageSecureFile(host.memoryActionsPath)),
+      cappedLimit,
+    );
+    return rows.map((row) => row.record);
+  } catch {
+    return [];
+  }
+}

package/src/storage/secure-line-reader.ts

@@ -3,6 +3,7 @@ import { lstat, open } from "node:fs/promises";
 import { createInterface } from "node:readline";
 
 import { isEncryptedFile, MAGIC_HEADER_SIZE } from "../secure-store/secure-fs.js";
+import type { ContextTransformTelemetryRecord } from "../active-context-transform.js";
 import type { MemoryActionEvent, MemoryLifecycleEvent } from "../types.js";
 
 /**
@@ -89,7 +90,11 @@ export async function readMemoryActionEventRowsFromLines(
     const line = row.trim();
     if (!line) continue;
     try {
-      const parsed = JSON.parse(line) as Partial<MemoryActionEvent>;
+      const parsed = JSON.parse(line) as Partial<MemoryActionEvent> & { recordKind?: unknown };
+      // Ledger discriminated union (#2347): any row carrying a `recordKind`
+      // belongs to another record family (e.g. context_transform) and must
+      // be ignored here — the legacy parser stays strict for its own kind.
+      if (parsed.recordKind !== undefined) continue;
       const outcome = parsed.outcome === "applied" || parsed.outcome === "skipped" || parsed.outcome === "failed"
         ? parsed.outcome
         : null;
@@ -116,6 +121,50 @@ export async function readMemoryActionEventRowsFromLines(
   return writeIndex === 0 ? out : [...out.slice(writeIndex), ...out.slice(0, writeIndex)];
 }
 
+/**
+ * Tail read for context-transform telemetry rows (#2347). Selects ONLY
+ * records discriminated by `recordKind: "context_transform"` — the sibling
+ * of `readMemoryActionEventRowsFromLines`, with the same O(limit) ring
+ * buffer and line-number semantics. Malformed rows are skipped fail-open;
+ * legacy action rows are never returned here.
+ */
+export async function readContextTransformRecordRowsFromLines(
+  lines: AsyncIterable<string>,
+  limit: number,
+): Promise<Array<{ line: number; record: ContextTransformTelemetryRecord }>> {
+  const out: Array<{ line: number; record: ContextTransformTelemetryRecord }> = [];
+  let writeIndex = 0;
+  let lineNumber = 0;
+  for await (const row of lines) {
+    lineNumber += 1;
+    const line = row.trim();
+    if (!line) continue;
+    try {
+      const parsed = JSON.parse(line) as Partial<ContextTransformTelemetryRecord>;
+      if (
+        parsed.recordKind === "context_transform" &&
+        typeof parsed.timestamp === "string" &&
+        typeof parsed.actionId === "string" &&
+        typeof parsed.planHash === "string"
+      ) {
+        const entry = {
+          line: lineNumber,
+          record: parsed as ContextTransformTelemetryRecord,
+        };
+        if (out.length < limit) {
+          out.push(entry);
+        } else {
+          out[writeIndex] = entry;
+          writeIndex = (writeIndex + 1) % limit;
+        }
+      }
+    } catch {
+      // Ignore malformed rows (fail-open).
+    }
+  }
+  return writeIndex === 0 ? out : [...out.slice(writeIndex), ...out.slice(0, writeIndex)];
+}
+
 /**
  * Validate that a parsed row carries every required lifecycle-event field.
  * Shared by the tail reader and the per-memory reader so both apply the EXACT

package/src/storage.ts

@@ -29,6 +29,8 @@ import { runCommittedInvalidation } from "./storage/committed-invalidation.js";
 import { renderProfileWithLastUpdated, stripOkfProfileFrontmatter, withOkfProfileFrontmatter } from "./storage/profile-header.js";
 import { parseQuestionFile as parseQuestionFileText } from "./storage/questions-file.js";
 import { assertNotOkfReservedBasename, OKF_QUESTION_TYPE, okfTypeForEntityKind, okfTypeForMemory } from "./okf/type-mapping.js";
+import { appendContextTransformRecords, readContextTransformRecords } from "./storage/context-transform-ledger.js";
+import type { ContextTransformTelemetryRecord } from "./active-context-transform.js";
 import { readMaybeEncryptedLines, readMemoryActionEventRowsFromLines } from "./storage/secure-line-reader.js";
 import {
   appendLifecycleEventsSerialized,
@@ -5595,7 +5597,8 @@ export class StorageManager extends TombstoneBlockedCaptureIndexHost {
     await this.appendStorageSecureFile(this.memoryActionsPath, payload);
     return events.length;
   }
-
+  async appendContextTransformRecords(records: ContextTransformTelemetryRecord[]) { return appendContextTransformRecords(this as never, records); }
+  async readContextTransformRecords(limit = 200) { return readContextTransformRecords(this as never, limit); }
   async appendMemoryLifecycleEvents(events: MemoryLifecycleEvent[]): Promise<number> {
     if (events.length === 0) return 0;
     await this.ensureDirectories();

package/src/types.ts

@@ -15,7 +15,7 @@ import type { DriftDetectionSettings, MemoryDriftProvenance, RecallDriftAnnotati
 import type { ProceduralMaintenanceConfig } from "./procedural/maintenance-config.js";
 import type { SkillProjectionConfig } from "./procedural/skill-projection.js";
 import type { ActionGateConfig } from "./coding/action-gate.js";
-
+import type { ActiveContextConfigFields } from "./active-context-config.js";
 import type { AmbientCaptureProvenance, BufferTurnOwner, SecurityConfig, OriginMetadata } from "./security/types.js";
 export type MemorySubject = "user" | "agent";
 export type SubjectGuardMode = "off" | "warn" | "enforce";
@@ -682,8 +682,7 @@ export interface SemanticChunkingConfigShape {
   fallbackToRecursive: boolean;
 }
 
-
-export interface PluginConfig extends BoundedJsonlStateConfig, SecurityConfig, DriftDetectionSettings {
+export interface PluginConfig extends BoundedJsonlStateConfig, SecurityConfig, DriftDetectionSettings, ActiveContextConfigFields {
   openaiApiKey: string | undefined;
   openaiBaseUrl: string | undefined;
   model: string;

package/src/wearables/http-glue.ts

@@ -0,0 +1,28 @@
+/**
+ * Wearables HTTP glue (issue #2047) — the wearables-input→400 error mapper
+ * extracted from access-http.ts so that size-grandfathered file keeps only
+ * thin route branches (same pattern as meetings/http-glue.ts). Returns false
+ * for non-wearables faults so backend errors keep flowing to the global 500
+ * handler.
+ */
+
+import type { ServerResponse } from "node:http";
+import { WearablesInputError } from "./errors.js";
+
+type RespondJson = (res: ServerResponse, status: number, payload: unknown) => void;
+
+export function respondWearablesErrorGlue(
+  respondJson: RespondJson,
+  res: ServerResponse,
+  err: unknown,
+): boolean {
+  if (err instanceof WearablesInputError) {
+    respondJson(res, 400, {
+      error: "invalid_request",
+      code: "invalid_request",
+      message: err.message,
+    });
+    return true;
+  }
+  return false;
+}

package/dist/chunk-4K7IW3F7.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/memory-worth-outcomes.ts"],"sourcesContent":["/**\n * Issue #560 PR 3 — Memory Worth outcome signal pipeline.\n *\n * PR 1 added `mw_success` / `mw_fail` fields to MemoryFrontmatter. PR 2 added\n * a pure scoring helper. This module adds the one piece tying the two\n * together: a way for callers to record a single outcome observation against\n * a memory, which increments the appropriate counter in frontmatter.\n *\n * The public entry point is `recordMemoryOutcome({ memoryPath, outcome, ... })`.\n * Callers pass the full path to the memory file (not just the ID) because in\n * the usual outcome source — the observation ledger — the memory path is\n * already captured in the event payload, and path-based lookup avoids a\n * full-corpus scan.\n *\n * Intentional properties:\n *   - Works on a per-memory basis (no bulk API in this slice). Bulk update is\n *     an easy layer on top of this once a second caller needs it.\n *   - Reuses the existing `updateMemoryFrontmatter(id, patch)` write path so\n *     unrelated fields (confidence, importance, lifecycle hooks, etc.) are\n *     preserved. The PR 1 serializer rejects negative / non-integer counters,\n *     so we rely on that for defensive validation rather than duplicating it.\n *   - Only instruments categories in `MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES`\n *     (currently `fact` and `procedure` — procedures joined in issue #2370 —\n *     matching `MEMORY_WORTH_ELIGIBLE_CATEGORIES` in operator-toolkit.ts for\n *     the doctor audit). Non-eligible memories return\n *     `{ ok: false, reason: \"ineligible_category\" }` rather than throwing so\n *     the caller — typically a ledger consumer draining heterogeneous events\n *     — doesn't need to pre-filter by category.\n *   - Missing / unknown memory IDs return `{ ok: false, reason: \"not_found\" }`\n *     rather than throwing, because outcome events may reference memories\n *     that were archived/deleted between the session and the ledger drain.\n *     That isn't an operator-actionable error.\n *   - On success, returns the new counter values so observability surfaces\n *     can report the increment without a second read.\n *\n * Out of scope (later PRs):\n *   - Recall filter reading the counters (PR 4).\n *   - Benchmark + default flip (PR 5).\n *   - Automatic increments from extraction or summarization. Only the\n *     explicit `MEM_OUTCOME` ledger tag or an MCP tool call drives writes.\n */\n\nimport path from \"node:path\";\n\nimport type { StorageManager } from \"./storage.js\";\nimport type { MemoryFrontmatter } from \"./types.js\";\n\n/**\n * Per-memory-ID serialization of the read-modify-write increment.\n *\n * Codex P1: without this, concurrent calls for the same memory race. Both\n * callers read the same `mw_*` values, each writes +1, and one increment\n * is lost — silently undercounting outcomes. We chain an async promise\n * per memory ID so read-then-write is atomic with respect to other calls\n * into this module.\n *\n * This serializes only THIS module. Direct writers (e.g. hand-rolled\n * frontmatter patches) still bypass the lock, but the documented surface\n * for Memory Worth increments is this function, and the bench only uses\n * this path.\n *\n * The lock map is WeakRef-free by design: the chain self-cleans once the\n * last pending write resolves (we delete the entry inside the `.finally`\n * of the tail), so memory use stays bounded even for long-running\n * processes that touch many different memory IDs.\n */\nconst outcomeLocks = new Map<string, Promise<unknown>>();\n\nfunction runSerialized<T>(key: string, task: () => Promise<T>): Promise<T> {\n  const prev = outcomeLocks.get(key) ?? Promise.resolve();\n  // Swallow upstream errors so a failed outcome for memory A doesn't\n  // permanently poison the chain for memory A. We still propagate our own\n  // result/errors to the caller.\n  const next = prev.catch(() => undefined).then(task);\n  outcomeLocks.set(key, next);\n  // Chain the cleanup off `next` BUT attach a `.catch` so the cleanup\n  // promise itself never surfaces as an unhandled rejection. The caller\n  // gets `next` back and handles it their own way; this detached cleanup\n  // chain has no observer, so without the .catch Node would crash the\n  // process on a task rejection even when the caller awaited `next` and\n  // handled the error correctly.\n  next\n    .then(\n      () => {\n        if (outcomeLocks.get(key) === next) outcomeLocks.delete(key);\n      },\n      () => {\n        if (outcomeLocks.get(key) === next) outcomeLocks.delete(key);\n      },\n    )\n    .catch(() => {\n      // Defensive no-op in case a hook inside the cleanup branches throws.\n    });\n  return next;\n}\n\n/**\n * Categories currently instrumented for Memory Worth counters. `procedure`\n * joined in issue #2370 — the procedure library-health maintenance loop\n * retires on failure-dominant `mw_*` counters, so injected procedures must\n * be able to accrue outcomes. Must be kept in sync with\n * `MEMORY_WORTH_ELIGIBLE_CATEGORIES` in `operator-toolkit.ts`. Declared\n * here (not imported) to avoid a circular dep with operator-toolkit, which\n * imports from this file's peers. The two constants are validated by a\n * test to stay in lockstep.\n */\nconst MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES: ReadonlySet<MemoryFrontmatter[\"category\"]> =\n  new Set([\"fact\", \"procedure\"]);\n\n/**\n * Exported so downstream tests / operators can query the allowlist without\n * re-declaring it. Returned as a frozen copy so consumers cannot mutate the\n * module-internal set.\n */\nexport function memoryWorthOutcomeEligibleCategories(): ReadonlySet<MemoryFrontmatter[\"category\"]> {\n  return new Set(MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES);\n}\n\n/**\n * The direction of an outcome — whether the session that consumed this\n * memory succeeded or failed. Restricted to a string literal union so\n * callers in TypeScript land can't pass arbitrary tags.\n */\nexport type MemoryOutcomeKind = \"success\" | \"failure\";\n\n/**\n * Arguments to `recordMemoryOutcome`.\n *\n * `memoryPath` is the filesystem path to the memory; we derive the ID from\n * the basename, matching how the operator-toolkit and recall layers map\n * paths to IDs.\n */\nexport interface RecordMemoryOutcomeInput {\n  /**\n   * Absolute or repo-relative path to the memory file. Typically the value\n   * of `MemoryFile.path` for a memory returned by `readAllMemories`.\n   */\n  memoryPath: string;\n  /** Outcome direction — \"success\" bumps mw_success; \"failure\" bumps mw_fail. */\n  outcome: MemoryOutcomeKind;\n  /**\n   * Optional observation timestamp for audit / telemetry. This PR doesn't\n   * persist the timestamp (PR 4/5 will use `lastAccessed`, which already\n   * covers the recency-decay requirement), but accepting it here keeps the\n   * call shape stable so future ledger integrations don't need a breaking\n   * change.\n   */\n  timestamp?: Date | string;\n}\n\n/**\n * Outcome of a `recordMemoryOutcome` call.\n *\n * `ok: true` means the counter was incremented and flushed. The returned\n * values reflect the post-increment state, so callers can log\n * `\"fact-xyz: 4/1 → 5/1\"` without re-reading.\n *\n * `ok: false` carries a short machine-readable `reason` so a ledger drainer\n * can aggregate metrics (\"how many events hit not_found this hour?\"). The\n * human-readable `message` is a friendlier version for logs.\n */\nexport type RecordMemoryOutcomeResult =\n  | {\n      ok: true;\n      memoryId: string;\n      /** New value of `mw_success` after the increment. */\n      mw_success: number;\n      /** New value of `mw_fail` after the increment. */\n      mw_fail: number;\n    }\n  | {\n      ok: false;\n      reason:\n        | \"not_found\"\n        | \"ineligible_category\"\n        | \"invalid_outcome\"\n        | \"invalid_path\";\n      message: string;\n    };\n\n/**\n * Extract the memory ID from a file path. Memory files are stored as\n * `<id>.md`, matching the rest of the system (see `getMemoryById`, which\n * infers paths from IDs).\n *\n * Returns `null` for any path that does not end in `.md`. The check is\n * unconditional — `path.basename` strips directory components before the\n * suffix check, so previous conditional logic silently accepted\n * directory-prefixed paths like `/tmp/facts/2026-01-01/not-a-memory`\n * (the basename `not-a-memory` is not equal to the input, so the `.md`\n * guard was skipped). The new check looks at the raw input once.\n */\nfunction memoryIdFromPath(memoryPath: string): string | null {\n  if (!memoryPath || typeof memoryPath !== \"string\") return null;\n  if (!memoryPath.endsWith(\".md\")) return null;\n  const basename = path.basename(memoryPath, \".md\");\n  if (!basename) return null;\n  return basename;\n}\n\n/**\n * Record a single outcome observation against a memory. Increments\n * `mw_success` or `mw_fail` on the memory's frontmatter (preserving all\n * other fields) via the existing `updateMemoryFrontmatter` write path.\n *\n * See the top-of-file doc comment for policy details (eligible categories,\n * error semantics, and what is intentionally out of scope).\n */\nexport async function recordMemoryOutcome(\n  storage: StorageManager,\n  input: RecordMemoryOutcomeInput,\n): Promise<RecordMemoryOutcomeResult> {\n  if (input.outcome !== \"success\" && input.outcome !== \"failure\") {\n    return {\n      ok: false,\n      reason: \"invalid_outcome\",\n      message: `outcome must be \"success\" or \"failure\"; got ${JSON.stringify(input.outcome)}`,\n    };\n  }\n\n  const memoryId = memoryIdFromPath(input.memoryPath);\n  if (memoryId === null) {\n    return {\n      ok: false,\n      reason: \"invalid_path\",\n      message: `memoryPath must end in .md; got ${JSON.stringify(input.memoryPath)}`,\n    };\n  }\n\n  // Serialize the read-modify-write per memory ID so concurrent callers\n  // (parallel ledger drain, multiple MCP clients, etc.) can't each read\n  // the same snapshot and race to write `+1`, losing an increment.\n  return runSerialized(memoryId, async () => {\n    const memory = await storage.getMemoryById(memoryId);\n    if (!memory) {\n      return {\n        ok: false,\n        reason: \"not_found\",\n        message: `no memory with id ${memoryId}`,\n      };\n    }\n\n    if (!MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES.has(memory.frontmatter.category)) {\n      return {\n        ok: false,\n        reason: \"ineligible_category\",\n        message: `category ${memory.frontmatter.category} is not instrumented for Memory Worth`,\n      };\n    }\n\n    // Absent counters are treated as 0 (matching the PR 1 semantics — legacy\n    // memories implicitly have Beta(1,1) priors). Increments land on the\n    // actual counter regardless of whether the field was previously set.\n    const currentSuccess = memory.frontmatter.mw_success ?? 0;\n    const currentFail = memory.frontmatter.mw_fail ?? 0;\n\n    const nextSuccess = input.outcome === \"success\" ? currentSuccess + 1 : currentSuccess;\n    const nextFail = input.outcome === \"failure\" ? currentFail + 1 : currentFail;\n\n    // `updateMemoryFrontmatter` goes through `writeMemoryFrontmatter`, which\n    // routes through the PR 1 serializer — so a stored corrupt value (e.g., a\n    // pre-existing float) would be rejected here. That is intentional: we\n    // refuse to layer a fresh increment on top of garbage. Operators should\n    // use `remnic doctor` to find and fix those rows before PR 4 ships.\n    //\n    // `updateMemoryFrontmatter` returns `false` when the memory is no\n    // longer present (archived / deleted between `getMemoryById` and the\n    // write). Surface that as `not_found` so callers see an honest result\n    // — silently returning `ok: true` with a counter that never landed\n    // would skew downstream worth scoring.\n    const updated = await storage.updateMemoryFrontmatter(memoryId, {\n      mw_success: nextSuccess,\n      mw_fail: nextFail,\n    });\n    if (!updated) {\n      return {\n        ok: false,\n        reason: \"not_found\",\n        message: `memory ${memoryId} disappeared between read and write`,\n      };\n    }\n\n    return {\n      ok: true,\n      memoryId,\n      mw_success: nextSuccess,\n      mw_fail: nextFail,\n    };\n  });\n}\n"],"mappings":";AA0CA,OAAO,UAAU;AAwBjB,IAAM,eAAe,oBAAI,IAA8B;AAEvD,SAAS,cAAiB,KAAa,MAAoC;AACzE,QAAM,OAAO,aAAa,IAAI,GAAG,KAAK,QAAQ,QAAQ;AAItD,QAAM,OAAO,KAAK,MAAM,MAAM,MAAS,EAAE,KAAK,IAAI;AAClD,eAAa,IAAI,KAAK,IAAI;AAO1B,OACG;AAAA,IACC,MAAM;AACJ,UAAI,aAAa,IAAI,GAAG,MAAM,KAAM,cAAa,OAAO,GAAG;AAAA,IAC7D;AAAA,IACA,MAAM;AACJ,UAAI,aAAa,IAAI,GAAG,MAAM,KAAM,cAAa,OAAO,GAAG;AAAA,IAC7D;AAAA,EACF,EACC,MAAM,MAAM;AAAA,EAEb,CAAC;AACH,SAAO;AACT;AAYA,IAAM,2CACJ,oBAAI,IAAI,CAAC,QAAQ,WAAW,CAAC;AAOxB,SAAS,uCAAmF;AACjG,SAAO,IAAI,IAAI,wCAAwC;AACzD;AA4EA,SAAS,iBAAiB,YAAmC;AAC3D,MAAI,CAAC,cAAc,OAAO,eAAe,SAAU,QAAO;AAC1D,MAAI,CAAC,WAAW,SAAS,KAAK,EAAG,QAAO;AACxC,QAAM,WAAW,KAAK,SAAS,YAAY,KAAK;AAChD,MAAI,CAAC,SAAU,QAAO;AACtB,SAAO;AACT;AAUA,eAAsB,oBACpB,SACA,OACoC;AACpC,MAAI,MAAM,YAAY,aAAa,MAAM,YAAY,WAAW;AAC9D,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,QAAQ;AAAA,MACR,SAAS,+CAA+C,KAAK,UAAU,MAAM,OAAO,CAAC;AAAA,IACvF;AAAA,EACF;AAEA,QAAM,WAAW,iBAAiB,MAAM,UAAU;AAClD,MAAI,aAAa,MAAM;AACrB,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,QAAQ;AAAA,MACR,SAAS,mCAAmC,KAAK,UAAU,MAAM,UAAU,CAAC;AAAA,IAC9E;AAAA,EACF;AAKA,SAAO,cAAc,UAAU,YAAY;AACzC,UAAM,SAAS,MAAM,QAAQ,cAAc,QAAQ;AACnD,QAAI,CAAC,QAAQ;AACX,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,QAAQ;AAAA,QACR,SAAS,qBAAqB,QAAQ;AAAA,MACxC;AAAA,IACF;AAEA,QAAI,CAAC,yCAAyC,IAAI,OAAO,YAAY,QAAQ,GAAG;AAC9E,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,QAAQ;AAAA,QACR,SAAS,YAAY,OAAO,YAAY,QAAQ;AAAA,MAClD;AAAA,IACF;AAKA,UAAM,iBAAiB,OAAO,YAAY,cAAc;AACxD,UAAM,cAAc,OAAO,YAAY,WAAW;AAElD,UAAM,cAAc,MAAM,YAAY,YAAY,iBAAiB,IAAI;AACvE,UAAM,WAAW,MAAM,YAAY,YAAY,cAAc,IAAI;AAajE,UAAM,UAAU,MAAM,QAAQ,wBAAwB,UAAU;AAAA,MAC9D,YAAY;AAAA,MACZ,SAAS;AAAA,IACX,CAAC;AACD,QAAI,CAAC,SAAS;AACZ,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,QAAQ;AAAA,QACR,SAAS,UAAU,QAAQ;AAAA,MAC7B;AAAA,IACF;AAEA,WAAO;AAAA,MACL,IAAI;AAAA,MACJ;AAAA,MACA,YAAY;AAAA,MACZ,SAAS;AAAA,IACX;AAAA,EACF,CAAC;AACH;","names":[]}