@remnic/core 10.0.11 → 10.0.13

package/src/calibration.test.ts

@@ -1,9 +1,33 @@
 import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
 import test from "node:test";
 
-import { synthesizeCalibrationRules, type CorrectionMemory } from "./calibration.js";
+import {
+  readCalibrationIndex,
+  runCalibrationConsolidation,
+  synthesizeCalibrationRules,
+  withAppliedCalibrationWeek,
+  type CalibrationRule,
+  type CorrectionMemory,
+} from "./calibration.js";
 import type { FallbackLlmClient } from "./fallback-llm.js";
 
+const existingRule: CalibrationRule = {
+  id: "cal-existing",
+  ruleType: "model_tendency",
+  condition: "When reporting status",
+  modelTendency: "It overstates progress",
+  userExpectation: "Report what finished",
+  calibration: "Name the checks that finished.",
+  confidence: 0.8,
+  evidenceCount: 2,
+  evidenceCorrectionIds: ["c1", "c2"],
+  createdAt: "2026-03-16T00:00:00.000Z",
+  lastReinforcedAt: "2026-03-16T00:00:00.000Z",
+};
+
 const corrections: CorrectionMemory[] = [
   {
     id: "c1",
@@ -97,3 +121,58 @@ test("synthesizeCalibrationRules clamps confidence and filters evidence IDs", as
   assert.deepEqual(rules[1]?.evidenceCorrectionIds, []);
   assert.equal(rules[1]?.evidenceCount, 0);
 });
+
+test("withAppliedCalibrationWeek commits the week stamp with the reinforced index", () => {
+  const stamped = withAppliedCalibrationWeek({
+    rules: [existingRule],
+    updatedAt: "2026-03-16T00:00:00.000Z",
+    totalCorrectionsAnalyzed: 4,
+  }, " 2026-W11 ");
+  assert.deepEqual(stamped.appliedWeekIds, ["2026-W11"]);
+  assert.equal(stamped.rules[0]?.evidenceCount, 2);
+
+  const preserved = withAppliedCalibrationWeek(stamped, " ");
+  assert.deepEqual(preserved.appliedWeekIds, ["2026-W11"]);
+  assert.deepEqual(withAppliedCalibrationWeek(stamped, "x".repeat(33)).appliedWeekIds, ["2026-W11"]);
+
+  // A later week keeps the earlier stamp: an out-of-order retry of week A
+  // after week B must still be recognized as already applied.
+  assert.deepEqual(withAppliedCalibrationWeek(stamped, "2026-W13").appliedWeekIds, ["2026-W11", "2026-W13"]);
+});
+
+test("runCalibrationConsolidation does not reinforce an already-applied week", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "calibration-week-"));
+  try {
+    // Legacy on-disk shape: the pre-list index persisted a single appliedWeekId.
+    const indexDir = path.join(memoryDir, "state", "calibration");
+    await mkdir(indexDir, { recursive: true });
+    const indexPath = path.join(indexDir, "calibration-index.json");
+    const body = JSON.stringify(
+      {
+        rules: [existingRule],
+        updatedAt: "2026-03-16T00:00:00.000Z",
+        totalCorrectionsAnalyzed: 3,
+        appliedWeekId: "2026-W11",
+      },
+      null,
+      2
+    );
+    await writeFile(indexPath, body, "utf8");
+
+    // Retry of the stamped week: no reinforcement, no rewrite.
+    const rules = await runCalibrationConsolidation({
+      memoryDir,
+      idempotencyKey: "2026-W11",
+    });
+    assert.equal(rules[0]?.evidenceCount, 2);
+    assert.equal(await readFile(indexPath, "utf8"), body);
+
+    // A retry of an older week stays recognized after a newer week applied:
+    // the reader folds the legacy single stamp into the applied-week list.
+    const reread = await readCalibrationIndex(memoryDir);
+    assert.deepEqual(reread.appliedWeekIds, ["2026-W11"]);
+    assert.equal(reread.rules[0]?.evidenceCount, 2);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/calibration.ts

@@ -13,7 +13,7 @@
  */
 
 import { createHash } from "node:crypto";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { resolveLocalLlmCapabilities } from "./capabilities.js";
 import { OUTPUT_LANGUAGE_POLICY } from "./extraction-prompt.js";
@@ -21,6 +21,7 @@ import { FallbackLlmClient } from "./fallback-llm.js";
 import { listJsonFiles } from "./json-store.js";
 import { LocalLlmClient } from "./local-llm.js";
 import { log } from "./logger.js";
+import { writeFileAtomically } from "./maintenance/atomic-file.js";
 import type { AgentPersonaModelConfig, GatewayConfig, PluginConfig } from "./types.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
@@ -43,6 +44,12 @@ export interface CalibrationIndex {
   rules: CalibrationRule[];
   updatedAt: string;
   totalCorrectionsAnalyzed: number;
+  /**
+   * Weeks whose rule reinforcement is already committed. A retry of any of
+   * these weeks must not increment `evidenceCount` again. Older indexes
+   * persisted a single `appliedWeekId`; reads fold it into this list.
+   */
+  appliedWeekIds?: string[];
 }
 
 // ─── Storage ─────────────────────────────────────────────────────────────────
@@ -55,24 +62,74 @@ function calibrationIndexPath(memoryDir: string): string {
   return path.join(calibrationDir(memoryDir), "calibration-index.json");
 }
 
+/** Week ids are short (`YYYY-Www`). Longer values are not used as stamps. */
+const MAX_APPLIED_WEEK_ID_LENGTH = 32;
+
+export function appliedCalibrationWeekId(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_APPLIED_WEEK_ID_LENGTH) return undefined;
+  return trimmed;
+}
+
 export async function readCalibrationIndex(memoryDir: string): Promise<CalibrationIndex> {
   try {
     const raw = JSON.parse(await readFile(calibrationIndexPath(memoryDir), "utf8"));
+    const appliedWeekIds = normalizeAppliedWeekIds(raw.appliedWeekIds, raw.appliedWeekId);
     return {
       rules: Array.isArray(raw.rules) ? raw.rules : [],
       updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : new Date().toISOString(),
       totalCorrectionsAnalyzed: typeof raw.totalCorrectionsAnalyzed === "number" ? raw.totalCorrectionsAnalyzed : 0,
+      ...(appliedWeekIds.length > 0 ? { appliedWeekIds } : {}),
     };
   } catch {
     return { rules: [], updatedAt: new Date().toISOString(), totalCorrectionsAnalyzed: 0 };
   }
 }
 
+function normalizeAppliedWeekIds(list: unknown, additional: unknown): string[] {
+  const weeks: string[] = [];
+  if (Array.isArray(list)) {
+    for (const entry of list) {
+      const week = appliedCalibrationWeekId(entry);
+      if (week && !weeks.includes(week)) weeks.push(week);
+    }
+  }
+  const extra = appliedCalibrationWeekId(additional);
+  if (extra && !weeks.includes(extra)) weeks.push(extra);
+  return weeks;
+}
+
+/**
+ * Attach the week stamp to the index that will be written with the reinforced
+ * rules. The stamp and the evidence increment commit together. Every
+ * previously applied week stays in the list so an out-of-order retry of an
+ * older week is still recognized as already applied.
+ */
+export function withAppliedCalibrationWeek(
+  index: CalibrationIndex,
+  idempotencyKey: string | undefined,
+): CalibrationIndex {
+  const appliedWeekIds = normalizeAppliedWeekIds(index.appliedWeekIds, idempotencyKey);
+  return {
+    rules: index.rules,
+    updatedAt: index.updatedAt,
+    totalCorrectionsAnalyzed: index.totalCorrectionsAnalyzed,
+    ...(appliedWeekIds.length > 0 ? { appliedWeekIds } : {}),
+  };
+}
+
 async function writeCalibrationIndex(memoryDir: string, index: CalibrationIndex): Promise<void> {
   const dir = calibrationDir(memoryDir);
   await mkdir(dir, { recursive: true });
-  index.updatedAt = new Date().toISOString();
-  await writeFile(calibrationIndexPath(memoryDir), JSON.stringify(index, null, 2), "utf8");
+  const appliedWeekIds = normalizeAppliedWeekIds(index.appliedWeekIds, undefined);
+  const stamped: CalibrationIndex = {
+    rules: index.rules,
+    updatedAt: new Date().toISOString(),
+    totalCorrectionsAnalyzed: index.totalCorrectionsAnalyzed,
+    ...(appliedWeekIds.length > 0 ? { appliedWeekIds } : {}),
+  };
+  await writeFileAtomically(calibrationIndexPath(memoryDir), JSON.stringify(stamped, null, 2));
 }
 
 // ─── Correction Reading ──────────────────────────────────────────────────────
@@ -432,8 +489,21 @@ export async function runCalibrationConsolidation(options: {
   modelChain?: AgentPersonaModelConfig;
   workspaceDir?: string;
   pluginConfig?: PluginConfig;
+  /**
+   * When set, a week whose reinforcement is already in the index is returned
+   * as-is. Weekly synthesis passes the ISO week id so a retry after a later
+   * artifact failure does not count the same corrections twice.
+   */
+  idempotencyKey?: string;
 }): Promise<CalibrationRule[]> {
   try {
+    const idempotencyKey = appliedCalibrationWeekId(options.idempotencyKey);
+    const existingIndex = await readCalibrationIndex(options.memoryDir);
+    if (idempotencyKey && (existingIndex.appliedWeekIds ?? []).includes(idempotencyKey)) {
+      log.debug(`[calibration] week ${idempotencyKey} already applied — skipping`);
+      return existingIndex.rules;
+    }
+
     const llm = resolveCalibrationChatClient(options);
     if (!llm) return [];
 
@@ -443,8 +513,6 @@ export async function runCalibrationConsolidation(options: {
       return [];
     }
 
-    const existingIndex = await readCalibrationIndex(options.memoryDir);
-
     const newRules = await synthesizeCalibrationRules(
       corrections,
       llm,
@@ -472,11 +540,12 @@ export async function runCalibrationConsolidation(options: {
     }
 
     const allRules = [...ruleMap.values()];
-    await writeCalibrationIndex(options.memoryDir, {
+    await writeCalibrationIndex(options.memoryDir, withAppliedCalibrationWeek({
       rules: allRules,
-      updatedAt: new Date().toISOString(),
+      updatedAt: existingIndex.updatedAt,
       totalCorrectionsAnalyzed: corrections.length,
-    });
+      appliedWeekIds: existingIndex.appliedWeekIds,
+    }, idempotencyKey));
 
     log.debug(`[calibration] synthesized ${newRules.length} new rule(s), ${allRules.length} total`);
     return allRules;

package/src/capabilities.test.ts

@@ -1090,6 +1090,7 @@ const CONSOLIDATION_FIELD_TO_FLAG: Record<keyof ConsolidationCapabilitySet, stri
   compoundingSemantic: "compoundingSemanticEnabled",
   abstractionAnchors: "abstractionAnchorsEnabled",
   compounding: "compoundingEnabled",
+  compoundingWeeklyCron: "compoundingWeeklyCronEnabled",
   calibration: "calibrationEnabled",
   semanticConsolidation: "semanticConsolidationEnabled",
   patternReinforcement: "patternReinforcementEnabled",

package/src/capabilities.ts

@@ -898,8 +898,8 @@ export interface ConsolidationCapabilitySet {
   readonly compoundingSemantic: boolean;
   /** `abstractionAnchorsEnabled` — abstraction-anchor extraction. */
   readonly abstractionAnchors: boolean;
-  /** `compoundingEnabled` — master compounding switch. */
-  readonly compounding: boolean;
+  /** `compoundingEnabled` master switch; `compoundingWeeklyCronEnabled` daemon weekly run. */
+  readonly compounding: boolean; readonly compoundingWeeklyCron: boolean;
   /** `calibrationEnabled` — memory calibration pass. */
   readonly calibration: boolean;
   /** `semanticConsolidationEnabled` — semantic consolidation pass. */
@@ -919,7 +919,7 @@ export type ConsolidationConfigProjection = Pick<
   PluginConfig,
   "compoundingSemanticEnabled" |
   "abstractionAnchorsEnabled" |
-  "compoundingEnabled" |
+  "compoundingEnabled" | "compoundingWeeklyCronEnabled" |
   "calibrationEnabled" |
   "semanticConsolidationEnabled" |
   "patternReinforcementEnabled" |
@@ -934,7 +934,7 @@ export function resolveConsolidationCapabilities(config: ConsolidationConfigProj
   return Object.freeze({
     compoundingSemantic: config.compoundingSemanticEnabled,
     abstractionAnchors: config.abstractionAnchorsEnabled,
-    compounding: config.compoundingEnabled,
+    compounding: config.compoundingEnabled, compoundingWeeklyCron: config.compoundingWeeklyCronEnabled,
     calibration: config.calibrationEnabled,
     semanticConsolidation: config.semanticConsolidationEnabled,
     patternReinforcement: config.patternReinforcementEnabled,

package/src/compounding/engine.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { isoWeekId } from "./iso-week.js";
+import { cadenceStaleWindowMs, isoWeekId } from "./iso-week.js";
 import { log } from "../logger.js";
 import { composeSalvagedEnvelope } from "../salvage-envelope.js";
 import { sanitizeMemoryContent } from "../sanitize.js";
@@ -11,6 +11,7 @@ import { migrateLegacyFeedbackInbox, resolveFeedbackInboxPath, type SharedFeedba
 import { parseContinuityImprovementLoops } from "../identity-continuity.js";
 import { resolveQmdCapabilities, type QmdConfigProjection, resolveConsolidationCapabilities } from "../capabilities.js";
 import { resolveConversationContextCapabilities } from "../capabilities.js";
+import { writeFileAtomically } from "../maintenance/atomic-file.js";
 import {
   actionEventsVisibleInStore, capWeeklyPatternDetails,
   buildActionFailurePatterns,
@@ -24,6 +25,7 @@ import {
   type WeeklyActionEvent,
   type WeeklyCorrectionEvidence,
 } from "./weekly-evidence.js";
+import { queueWeeklySynthesis } from "./weekly-synthesis-queue.js";
 
 type MistakesFile = {
   version?: number;
@@ -422,20 +424,18 @@ function monthIdFromIsoWeek(weekId: string): string {
   return isoMonthId(monday);
 }
 
-function cadenceStaleWindowMs(cadence: "daily" | "weekly" | "monthly" | "quarterly"): number {
-  switch (cadence) {
-    case "daily":
-      return 2 * 24 * 60 * 60 * 1000;
-    case "weekly":
-      return 10 * 24 * 60 * 60 * 1000;
-    case "monthly":
-      return 45 * 24 * 60 * 60 * 1000;
-    case "quarterly":
-      return 120 * 24 * 60 * 60 * 1000;
-    default:
-      return 45 * 24 * 60 * 60 * 1000;
-  }
-}
+export type WeeklySynthesisOptions = { weekId?: string };
+
+export type WeeklySynthesisResult = {
+  weekId: string;
+  reportPath: string;
+  reportJsonPath: string;
+  mistakesCount: number;
+  rubricsPath: string;
+  rubricsIndexPath: string;
+  promotionCandidateCount: number;
+};
+
 
 export class CompoundingEngine {
   private readonly weeklyDir: string;
@@ -474,17 +474,12 @@ export class CompoundingEngine {
     await mkdir(this.rubricsWorkflowsDir, { recursive: true });
   }
 
-  async synthesizeWeekly(opts?: {
-    weekId?: string;
-  }): Promise<{
-    weekId: string;
-    reportPath: string;
-    reportJsonPath: string;
-    mistakesCount: number;
-    rubricsPath: string;
-    rubricsIndexPath: string;
-    promotionCandidateCount: number;
-  }> {
+  /** Serialized per memory directory — see weekly-synthesis-queue.ts. */
+  async synthesizeWeekly(opts?: WeeklySynthesisOptions): Promise<WeeklySynthesisResult> {
+    return await queueWeeklySynthesis(this.config.memoryDir, () => this.synthesizeWeeklyExclusive(opts));
+  }
+
+  private async synthesizeWeeklyExclusive(opts?: WeeklySynthesisOptions): Promise<WeeklySynthesisResult> {
     await this.ensureDirs();
     const weekId = opts?.weekId ?? isoWeekId(new Date());
 
@@ -559,11 +554,16 @@ export class CompoundingEngine {
         log.warn(`[cmc] causal consolidation in synthesizeWeekly failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);
       }
     }
-    // PEDC: Run calibration consolidation during weekly synthesis
-    if (resolveConsolidationCapabilities(this.config).calibration) {
+    // PEDC: calibration consolidation, keyed by the week id so a retry does
+    // not reinforce the same rules. Only a completed week consolidates: a
+    // manual in-progress-week run must not double-count partial evidence.
+    if (resolveConsolidationCapabilities(this.config).calibration && weekId < isoWeekId(new Date())) {
       try {
         const { calibrationConsolidationInput, runCalibrationConsolidation } = await import("../calibration.js");
-        const calRules = await runCalibrationConsolidation(calibrationConsolidationInput(this.config));
+        const calRules = await runCalibrationConsolidation({
+          ...calibrationConsolidationInput(this.config),
+          idempotencyKey: weekId,
+        });
         log.debug(`[calibration] weekly synthesis produced ${calRules.length} calibration rule(s)`);
       } catch (error) {
         log.warn(`[calibration] weekly consolidation failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);
@@ -573,10 +573,10 @@ export class CompoundingEngine {
       ? await this.readContinuityAuditReferences(weekId)
       : { monthId: monthIdFromIsoWeek(weekId), weeklyPath: null, monthlyPath: null };
 
-    // Write weekly report (always, even if empty: "day-one outcomes").
+    // The markdown report is the completion marker, so it is written after the
+    // JSON, rubrics, and mistakes artifacts. A crash before that write retries.
     const reportPath = path.join(this.weeklyDir, `${weekId}.md`);
     const md = this.formatWeeklyReport(weekId, entries, mistakes.patterns, mistakes.details, continuity, outcomeSummary, promotionCandidates);
-    await writeFile(reportPath, md, "utf-8");
 
     const reportJsonPath = path.join(this.weeklyDir, `${weekId}.json`);
     const weeklyArtifact: WeeklyCompoundingArtifact = {
@@ -633,6 +633,7 @@ export class CompoundingEngine {
       }, null, 2) + "\n",
       "utf-8",
     );
+    await writeFileAtomically(reportPath, md);
 
     log.info(
       `compounding: wrote weekly=${reportPath} weeklyJson=${reportJsonPath} rubrics=${this.rubricsPath} rubricsIndex=${this.rubricsIndexPath} mistakes=${this.mistakesPath}`,

package/src/compounding/iso-week.ts

@@ -58,3 +58,19 @@ export function isIsoWeekId(weekId: string): boolean {
   const weekNum = Number(week);
   return weekNum >= 1 && weekNum <= 53;
 }
+
+/** How long a rubric cadence may go unreviewed before it counts as stale. */
+export function cadenceStaleWindowMs(cadence: "daily" | "weekly" | "monthly" | "quarterly"): number {
+  switch (cadence) {
+    case "daily":
+      return 2 * 24 * 60 * 60 * 1000;
+    case "weekly":
+      return 10 * 24 * 60 * 60 * 1000;
+    case "monthly":
+      return 45 * 24 * 60 * 60 * 1000;
+    case "quarterly":
+      return 120 * 24 * 60 * 60 * 1000;
+    default:
+      return 45 * 24 * 60 * 60 * 1000;
+  }
+}