Skip to content

armgit / mso

Public Imported from GitHub
0

Browser-based graphical shell and control plane for a Linux server you own — real terminal, file manager, live metrics and BYOK AI in one mobile-first workspace. Next.js 16 · React 19 · node-pty · Tailwind v4 · shadcn/ui. Public alpha, self-hosted.

fix(agent): calibrate correction memory semantics

Rahmand249da47f3f2
diff --git a/lib/agent/memory-resolution.ts b/lib/agent/memory-resolution.ts
index 2b8b7252..9377ffee 100644
--- a/lib/agent/memory-resolution.ts
+++ b/lib/agent/memory-resolution.ts
@@ -18,6 +18,14 @@ export function recordEffectiveAt(record: AgentMemoryRecord, at: string): boolea
return validFrom <= target && target < validUntil && target < retractedAt && target < supersededAt;
}
+export function recordCanBeEffectiveAtOrAfter(record: AgentMemoryRecord, at: string): boolean {
+ const target = Date.parse(at);
+ if (!Number.isFinite(target)) throw new Error("memory query time must be ISO-8601");
+ const start = Math.max(target, ms(record.validFrom));
+ const end = Math.min(ms(record.validUntil), ms(record.retractedAt), ms(record.supersededAt));
+ return start < end;
+}
+
function compare(a: AgentMemoryRecord, b: AgentMemoryRecord): number {
const authority = AUTHORITY_RANK[b.provenance.authority] - AUTHORITY_RANK[a.provenance.authority];
if (authority) return authority;
diff --git a/lib/agent/memory-store.test.ts b/lib/agent/memory-store.test.ts
index eaa98418..58231f45 100644
--- a/lib/agent/memory-store.test.ts
+++ b/lib/agent/memory-store.test.ts
@@ -73,6 +73,35 @@ describe("typed provenance-aware agent memory", () => {
expect(after.records[0].record.value).toBe("Singapore");
});
+ it("forgets scheduled future claims so a deleted key cannot resurrect later", async () => {
+ const principal = "memory:forget-future";
+ const now = Date.now(), tomorrow = new Date(now + 86_400_000), later = new Date(now + 2 * 86_400_000);
+ await store.rememberAgentMemory(principal, "USER.md", "Office", "Jakarta", {
+ validFrom: new Date(now - 60_000).toISOString(),
+ });
+ await store.rememberAgentMemory(principal, "USER.md", "Office", "Singapore", { validFrom: tomorrow.toISOString() });
+ await store.forgetAgentMemory(principal, "USER.md", "Office");
+ expect((await store.queryAgentMemory(principal, { query: "office" })).records).toHaveLength(0);
+ expect((await store.queryAgentMemory(principal, { query: "office", at: later.toISOString() })).records).toHaveLength(0);
+ const history = await store.queryAgentMemory(principal, { query: "office", includeHistory: true, limit: 10 });
+ expect(history.records).toHaveLength(2);
+ expect(history.records.every((row) => row.record.retractedAt)).toBe(true);
+ });
+
+ it("forgets current claims without rewriting already-finished historical evidence", async () => {
+ const principal = "memory:forget-history";
+ const now = Date.now(), old = new Date(now - 3 * 86_400_000), recent = new Date(now - 86_400_000);
+ await store.rememberAgentMemory(principal, "MEMORY.md", "Region", "Jakarta", { validFrom: old.toISOString() });
+ await store.rememberAgentMemory(principal, "MEMORY.md", "Region", "Singapore", { validFrom: recent.toISOString() });
+ await store.forgetAgentMemory(principal, "MEMORY.md", "Region");
+ const history = await store.queryAgentMemory(principal, { query: "region", includeHistory: true, limit: 10 });
+ const jakarta = history.records.find((row) => row.record.value === "Jakarta")?.record;
+ const singapore = history.records.find((row) => row.record.value === "Singapore")?.record;
+ expect(jakarta?.supersededAt).toBe(recent.toISOString());
+ expect(jakarta?.retractedAt).toBeUndefined();
+ expect(singapore?.retractedAt).toBeTruthy();
+ });
+
it("retracts active claims on forget and keeps ledger/doc permissions private", async () => {
const principal = "memory:forget";
await store.rememberAgentMemory(principal, "MEMORY.md", "Temporary note", "Delete me");
diff --git a/lib/agent/memory-store.ts b/lib/agent/memory-store.ts
index 81d57d1f..f2e58960 100644
--- a/lib/agent/memory-store.ts
+++ b/lib/agent/memory-store.ts
@@ -5,7 +5,7 @@ import path from "node:path";
import { withSecurityStoreLock } from "@/lib/security-store-lock";
import { ledgerFile, materializeDocuments, readMemoryLedger, seedLedger, writeMemoryLedger } from "./memory-ledger";
import { queryMemoryLedger } from "./memory-query";
-import { recordEffectiveAt } from "./memory-resolution";
+import { recordCanBeEffectiveAtOrAfter, recordEffectiveAt } from "./memory-resolution";
import type { AgentMemoryDocument, AgentMemoryLedger, AgentMemoryQuery, AgentMemoryRecord, AgentMemoryWriteOptions } from "./memory-types";
export type { AgentMemoryDocument, AgentMemoryKind, AgentMemoryQuery, AgentMemoryRecord, AgentMemorySensitivity, AgentMemoryWriteOptions } from "./memory-types";
@@ -117,7 +117,9 @@ export async function forgetAgentMemory(principal: string, document: AgentMemory
const safeKey = cleanKey(key), now = new Date().toISOString(); let result!: AgentMemoryLedger;
await withSecurityStoreLock(ledgerFile(dirFor(principal)), async () => {
const current = await readMemoryLedger(dirFor(principal)) ?? await (async () => { const docs = await legacyDocs(principal); return seedLedger(docs.user, docs.memory, now); })();
- for (const row of current.records) if (row.document === document && row.key === safeKey && recordEffectiveAt(row, now)) row.retractedAt = now;
+ for (const row of current.records) {
+ if (row.document === document && row.key === safeKey && recordCanBeEffectiveAtOrAfter(row, now)) row.retractedAt = now;
+ }
current.updatedAt = now; await writeMemoryLedger(dirFor(principal), current); await persistProjection(principal, current, now); result = current;
});
return snapshotFromLedger(result, now);
diff --git a/package.json b/package.json
index ec99440a..74294b98 100644
--- a/package.json
+++ b/package.json
@@ -28,6 +28,7 @@
"comparison": "node scripts/gen-comparison.mjs",
"bench:cognitive": "bun scripts/bench-cognitive-runtime.mjs",
"bench:memory": "bun scripts/bench-memory-retrieval.mjs",
+ "bench:memory:calibration": "bun scripts/bench-memory-calibration.mjs",
"bench:quality": "bun scripts/bench-task-quality.mjs",
"bench:agents": "bun scripts/bench-agent-comparison.mjs",
"forge:sandbox": "bash scripts/provision-forge-sandbox.sh",
diff --git a/scripts/bench-memory-calibration.mjs b/scripts/bench-memory-calibration.mjs
new file mode 100755
index 00000000..7df40e82
--- /dev/null
+++ b/scripts/bench-memory-calibration.mjs
@@ -0,0 +1,133 @@
+#!/usr/bin/env bun
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+function pct(n, d) { return d ? Math.round((n / d) * 1000) / 10 : 0; }
+function pct2(n, d) { return d ? Math.round((n / d) * 10_000) / 100 : 0; }
+function bytes(value) { return Buffer.byteLength(typeof value === "string" ? value : JSON.stringify(value), "utf8"); }
+function principalDir(root, principal) { return path.join(root, createHash("sha256").update(principal).digest("hex").slice(0, 32)); }
+function semantic(result) {
+ return result.records.map((row) => ({ value: row.record.value, authority: row.record.provenance.authority, confidence: row.record.confidence, conflicts: row.conflicts.map((r) => r.value).sort() }));
+}
+
+export async function runMemoryCalibration({ correctionDepth = 40 } = {}) {
+ const depth = Math.max(8, Math.min(200, Math.trunc(correctionDepth) || 40));
+ const root = await mkdtemp(path.join(os.tmpdir(), "mso-memory-p9-"));
+ const previous = process.env.OS_AGENT_MEMORY_DIR;
+ process.env.OS_AGENT_MEMORY_DIR = root;
+ try {
+ const store = await import("../lib/agent/memory-store.ts");
+ const now = Date.now();
+ const T = {
+ old: new Date(now - 3 * 86_400_000).toISOString(),
+ recent: new Date(now - 86_400_000).toISOString(),
+ future: new Date(now + 86_400_000).toISOString(),
+ later: new Date(now + 2 * 86_400_000).toISOString(),
+ };
+ const scenarios = [];
+
+ {
+ const principal = "p9:authority";
+ await store.rememberAgentMemory(principal, "MEMORY.md", "Release region", "Singapore", { mode: "claim", confidence: 1, provenance: { authority: "observed", channel: "system", observedAt: T.recent } });
+ await store.rememberAgentMemory(principal, "MEMORY.md", "Release region", "Jakarta", { mode: "claim", confidence: 0.4, provenance: { authority: "explicit", channel: "mcp", observedAt: T.old } });
+ const a = await store.queryAgentMemory(principal, { query: "release region" }), b = await store.queryAgentMemory(principal, { query: "release region" });
+ scenarios.push({ id: "explicit-authority", pass: a.records[0]?.record.value === "Jakarta" && a.records[0]?.conflicts.some((r) => r.value === "Singapore"), deterministic: JSON.stringify(semantic(a)) === JSON.stringify(semantic(b)) });
+ }
+
+ {
+ const principal = "p9:confidence-recency";
+ await store.rememberAgentMemory(principal, "MEMORY.md", "Runtime", "Bun", { mode: "claim", confidence: 0.9, provenance: { authority: "observed", channel: "system", observedAt: T.old } });
+ await store.rememberAgentMemory(principal, "MEMORY.md", "Runtime", "Node", { mode: "claim", confidence: 0.6, provenance: { authority: "observed", channel: "system", observedAt: T.recent } });
+ const confidence = await store.queryAgentMemory(principal, { query: "runtime" });
+ await store.rememberAgentMemory(principal, "MEMORY.md", "Branch", "develop", { mode: "claim", confidence: 0.8, provenance: { authority: "observed", channel: "system", observedAt: T.old } });
+ await store.rememberAgentMemory(principal, "MEMORY.md", "Branch", "main", { mode: "claim", confidence: 0.8, provenance: { authority: "observed", channel: "system", observedAt: T.recent } });
+ const recency = await store.queryAgentMemory(principal, { query: "branch" });
+ scenarios.push({ id: "confidence-then-recency", pass: confidence.records[0]?.record.value === "Bun" && recency.records[0]?.record.value === "main", deterministic: true });
+ }
+
+ {
+ const principal = "p9:future-transition";
+ await store.rememberAgentMemory(principal, "USER.md", "Office", "Jakarta", { validFrom: T.old });
+ await store.rememberAgentMemory(principal, "USER.md", "Office", "Singapore", { validFrom: T.future });
+ const before = await store.queryAgentMemory(principal, { query: "office", at: new Date(now).toISOString() });
+ const after = await store.queryAgentMemory(principal, { query: "office", at: T.later });
+ scenarios.push({ id: "future-replacement-boundary", pass: before.records[0]?.record.value === "Jakarta" && after.records[0]?.record.value === "Singapore", deterministic: true });
+ }
+
+ {
+ const principal = "p9:forget-future";
+ await store.rememberAgentMemory(principal, "USER.md", "Office", "Jakarta", { validFrom: T.old });
+ await store.rememberAgentMemory(principal, "USER.md", "Office", "Singapore", { validFrom: T.future });
+ await store.forgetAgentMemory(principal, "USER.md", "Office");
+ const current = await store.queryAgentMemory(principal, { query: "office" });
+ const future = await store.queryAgentMemory(principal, { query: "office", at: T.later });
+ const history = await store.queryAgentMemory(principal, { query: "office", includeHistory: true, limit: 10 });
+ scenarios.push({ id: "forget-no-future-resurrection", pass: current.records.length === 0 && future.records.length === 0 && history.records.length === 2 && history.records.every((row) => row.record.retractedAt), deterministic: true });
+ }
+
+ {
+ const principal = "p9:forget-history";
+ await store.rememberAgentMemory(principal, "MEMORY.md", "Region", "Jakarta", { validFrom: T.old });
+ await store.rememberAgentMemory(principal, "MEMORY.md", "Region", "Singapore", { validFrom: T.recent });
+ await store.forgetAgentMemory(principal, "MEMORY.md", "Region");
+ const history = await store.queryAgentMemory(principal, { query: "region", includeHistory: true, limit: 10 });
+ const jakarta = history.records.find((row) => row.record.value === "Jakarta")?.record;
+ const singapore = history.records.find((row) => row.record.value === "Singapore")?.record;
+ scenarios.push({
+ id: "forget-preserves-finished-history",
+ pass: Boolean(jakarta?.supersededAt) && !jakarta?.retractedAt && Boolean(singapore?.retractedAt),
+ deterministic: true,
+ });
+ }
+
+ let projection = null;
+ {
+ const principal = "p9:repeated-corrections";
+ for (let i = 0; i < depth; i++) await store.rememberAgentMemory(principal, "MEMORY.md", "Preferred runtime", `Runtime-${i + 1}`);
+ const resolved = await store.queryAgentMemory(principal, { query: "preferred runtime" });
+ const history = await store.queryAgentMemory(principal, { query: "preferred runtime", includeHistory: true, limit: 100 });
+ const snapshot = await store.readAgentMemory(principal);
+ const ledgerRaw = await readFile(path.join(principalDir(root, principal), "records-v1.json"), "utf8");
+ const ledger = JSON.parse(ledgerRaw);
+ const ledgerBytes = bytes(ledgerRaw);
+ const resolvedBytes = bytes({ user: snapshot.user, memory: snapshot.memory });
+ projection = {
+ correctionDepth: depth, ledgerRecords: ledger.records.length, historyRowsReturned: history.records.length, historyLimit: 100,
+ resolvedRecords: resolved.records.length, finalValue: resolved.records[0]?.record.value ?? null, ledgerBytes,
+ resolvedProjectionBytes: resolvedBytes, projectionReductionPct: pct2(ledgerBytes - resolvedBytes, ledgerBytes),
+ };
+ scenarios.push({
+ id: "repeated-correction-projection",
+ pass: ledger.records.length === depth && history.records.length === Math.min(depth, 100) && resolved.records.length === 1
+ && resolved.records[0]?.record.value === `Runtime-${depth}` && resolvedBytes < ledgerBytes,
+ deterministic: true,
+ });
+ }
+
+ const passed = scenarios.filter((row) => row.pass && row.deterministic).length;
+ return {
+ calibrationVersion: "mso-memory-calibration-v1", scenarioCount: scenarios.length, passed,
+ accuracyPct: pct(passed, scenarios.length), deterministic: scenarios.every((row) => row.deterministic),
+ scenarios, projection,
+ graphMemoryRequiredByCalibration: false,
+ note: "Calibration uses an isolated temporary memory root. It checks keyed ledger semantics and resolved-context projection only; it does not mutate real user memory, grant authority, or infer a need for graph memory from synthetic complexity.",
+ };
+ } finally {
+ if (previous === undefined) delete process.env.OS_AGENT_MEMORY_DIR; else process.env.OS_AGENT_MEMORY_DIR = previous;
+ await rm(root, { recursive: true, force: true });
+ }
+}
+
+if (import.meta.main) {
+ const i = process.argv.indexOf("--corrections"), correctionDepth = i >= 0 ? Number(process.argv[i + 1]) : 40;
+ const result = await runMemoryCalibration({ correctionDepth });
+ if (process.argv.includes("--json")) console.log(JSON.stringify(result, null, 2));
+ else {
+ console.log(`MSO memory calibration · ${result.passed}/${result.scenarioCount} pass · deterministic=${result.deterministic}`);
+ for (const row of result.scenarios) console.log(` ${row.pass && row.deterministic ? "PASS" : "FAIL"} ${row.id}`);
+ console.log(` repeated corrections ${result.projection.correctionDepth} → ${result.projection.resolvedRecords} resolved record · projection ${result.projection.projectionReductionPct}% smaller than ledger`);
+ }
+ if (result.accuracyPct !== 100 || !result.deterministic) process.exitCode = 1;
+}
diff --git a/scripts/bench-memory-calibration.test.ts b/scripts/bench-memory-calibration.test.ts
new file mode 100644
index 00000000..aeeb303a
--- /dev/null
+++ b/scripts/bench-memory-calibration.test.ts
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { runMemoryCalibration } from "./bench-memory-calibration.mjs";
+
+describe("P9 memory calibration", () => {
+ it("keeps repeated corrections, temporal replacement, authority, and forget semantics deterministic", async () => {
+ const result = await runMemoryCalibration({ correctionDepth: 12 });
+ expect(result).toMatchObject({ calibrationVersion: "mso-memory-calibration-v1", scenarioCount: 6, passed: 6, accuracyPct: 100, deterministic: true, graphMemoryRequiredByCalibration: false });
+ expect(result.scenarios.find((row) => row.id === "forget-no-future-resurrection")?.pass).toBe(true);
+ expect(result.projection).toMatchObject({ correctionDepth: 12, ledgerRecords: 12, resolvedRecords: 1, finalValue: "Runtime-12" });
+ expect(result.projection.projectionReductionPct).toBeGreaterThan(50);
+ });
+});