File size: 3,809 Bytes
fc93158
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
import fs from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { queryOmegaDurableMemory, resolveOmegaDurableMemoryFile } from "./durable-memory.js";
import { recordOmegaSessionOutcome } from "./session-context.js";

describe("omega durable memory", () => {
  let workspaceRoot = "";
  const sessionKey = "agent:tester:main";

  beforeEach(async () => {
    workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), "omega-durable-memory-"));
  });

  afterEach(async () => {
    await fs.rm(workspaceRoot, { recursive: true, force: true });
  });

  it("admits only verified successes and repeated failures", async () => {
    await recordOmegaSessionOutcome({
      workspaceRoot,
      sessionKey,
      task: "Inspect flaky auth retry path",
      validation: { expectsJson: false, expectedKeys: [], expectedPaths: ["src/auth.ts"] },
      outcome: { status: "error", errorKind: "target_not_touched" },
    });

    const afterFirstFailure = await queryOmegaDurableMemory({
      workspaceRoot,
      sessionKey,
      task: "auth retry",
      expectedPaths: ["src/auth.ts"],
    });
    expect(afterFirstFailure).toHaveLength(0);

    await recordOmegaSessionOutcome({
      workspaceRoot,
      sessionKey,
      task: "Inspect flaky auth retry path",
      validation: { expectsJson: false, expectedKeys: [], expectedPaths: ["src/auth.ts"] },
      outcome: { status: "error", errorKind: "target_not_touched" },
    });

    await recordOmegaSessionOutcome({
      workspaceRoot,
      sessionKey,
      task: "Fix auth retry path",
      validation: { expectsJson: false, expectedKeys: [], expectedPaths: ["src/auth.ts"] },
      outcome: {
        status: "ok",
        observedChangedFiles: ["src/auth.ts"],
        writeOk: true,
      },
    });

    const recalled = await queryOmegaDurableMemory({
      workspaceRoot,
      sessionKey,
      task: "fix auth retry bug",
      expectedPaths: ["src/auth.ts"],
    });

    expect(recalled.map((entry) => entry.kind)).toEqual(
      expect.arrayContaining(["verified_success", "repeated_failure"]),
    );
    const repeatedFailure = recalled.find((entry) => entry.kind === "repeated_failure");
    const verifiedSuccess = recalled.find((entry) => entry.kind === "verified_success");
    expect(verifiedSuccess?.targets).toContain("src/auth.ts");
    expect(repeatedFailure?.failureCount).toBe(2);
  });

  it("persists durable memory on disk", async () => {
    await recordOmegaSessionOutcome({
      workspaceRoot,
      sessionKey,
      task: "Update session continuity cache",
      validation: { expectsJson: true, expectedKeys: ["ok"], expectedPaths: [] },
      outcome: { status: "ok", structuredOk: true },
    });

    const file = resolveOmegaDurableMemoryFile({ workspaceRoot, sessionKey });
    const raw = await fs.readFile(file, "utf-8");
    expect(raw).toContain("Update session continuity cache");
    expect(raw).toContain("verified_success");
  });

  it("persists locality telemetry for later routing decisions", async () => {
    await recordOmegaSessionOutcome({
      workspaceRoot,
      sessionKey,
      task: "Patch isolated config path",
      validation: { expectsJson: false, expectedKeys: [], expectedPaths: ["src/config.ts"] },
      outcome: {
        status: "ok",
        observedChangedFiles: ["src/config.ts"],
        writeOk: true,
        localityScore: 1,
        protectedPreservationRate: 1,
      },
    });

    const recalled = await queryOmegaDurableMemory({
      workspaceRoot,
      sessionKey,
      task: "patch config",
      expectedPaths: ["src/config.ts"],
    });

    expect(recalled[0]).toMatchObject({
      localityScore: 1,
      protectedPreservationRate: 1,
    });
  });
});