wehub-resource-sync
869 lines
29 KiB
TypeScript
869 lines
29 KiB
TypeScript
import { describe, it, expect, beforeEach, vi } from "vitest";
|
|
|
|
vi.mock("../src/logger.js", () => ({
|
|
logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
|
|
}));
|
|
|
|
import { registerDiagnosticsFunction } from "../src/functions/diagnostics.js";
|
|
import type {
|
|
Action,
|
|
ActionEdge,
|
|
DiagnosticCheck,
|
|
Lease,
|
|
Sentinel,
|
|
Sketch,
|
|
Signal,
|
|
Session,
|
|
Memory,
|
|
MeshPeer,
|
|
} from "../src/types.js";
|
|
import { KV } from "../src/state/schema.js";
|
|
|
|
function mockKV() {
|
|
const store = new Map<string, Map<string, unknown>>();
|
|
return {
|
|
get: async <T>(scope: string, key: string): Promise<T | null> => {
|
|
return (store.get(scope)?.get(key) as T) ?? null;
|
|
},
|
|
set: async <T>(scope: string, key: string, data: T): Promise<T> => {
|
|
if (!store.has(scope)) store.set(scope, new Map());
|
|
store.get(scope)!.set(key, data);
|
|
return data;
|
|
},
|
|
delete: async (scope: string, key: string): Promise<void> => {
|
|
store.get(scope)?.delete(key);
|
|
},
|
|
list: async <T>(scope: string): Promise<T[]> => {
|
|
const entries = store.get(scope);
|
|
return entries ? (Array.from(entries.values()) as T[]) : [];
|
|
},
|
|
};
|
|
}
|
|
|
|
function mockSdk() {
|
|
const functions = new Map<string, Function>();
|
|
return {
|
|
registerFunction: (idOrOpts: string | { id: string }, handler: Function) => {
|
|
const id = typeof idOrOpts === "string" ? idOrOpts : idOrOpts.id;
|
|
functions.set(id, handler);
|
|
},
|
|
registerTrigger: () => {},
|
|
trigger: async (idOrInput: string | { function_id: string; payload: unknown }, data?: unknown) => {
|
|
const id = typeof idOrInput === "string" ? idOrInput : idOrInput.function_id;
|
|
const payload = typeof idOrInput === "string" ? data : idOrInput.payload;
|
|
const fn = functions.get(id);
|
|
if (!fn) throw new Error(`No function: ${id}`);
|
|
return fn(payload);
|
|
},
|
|
};
|
|
}
|
|
|
|
function makeAction(overrides: Partial<Action> = {}): Action {
|
|
return {
|
|
id: `act_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
|
|
title: "Test action",
|
|
description: "",
|
|
status: "pending",
|
|
priority: 5,
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
createdBy: "agent-1",
|
|
tags: [],
|
|
sourceObservationIds: [],
|
|
sourceMemoryIds: [],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeLease(overrides: Partial<Lease> = {}): Lease {
|
|
return {
|
|
id: `lease_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
|
|
actionId: "act_missing",
|
|
agentId: "agent-1",
|
|
acquiredAt: new Date().toISOString(),
|
|
expiresAt: new Date(Date.now() + 60_000).toISOString(),
|
|
status: "active",
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeEdge(overrides: Partial<ActionEdge> = {}): ActionEdge {
|
|
return {
|
|
id: `ae_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
|
|
type: "requires",
|
|
sourceActionId: "src",
|
|
targetActionId: "tgt",
|
|
createdAt: new Date().toISOString(),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeSentinel(overrides: Partial<Sentinel> = {}): Sentinel {
|
|
return {
|
|
id: `sen_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
|
|
name: "Test sentinel",
|
|
type: "timer",
|
|
status: "watching",
|
|
config: {},
|
|
createdAt: new Date().toISOString(),
|
|
linkedActionIds: [],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeSketch(overrides: Partial<Sketch> = {}): Sketch {
|
|
return {
|
|
id: `sk_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
|
|
title: "Test sketch",
|
|
description: "",
|
|
status: "active",
|
|
actionIds: [],
|
|
createdAt: new Date().toISOString(),
|
|
expiresAt: new Date(Date.now() + 60_000).toISOString(),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeSignal(overrides: Partial<Signal> = {}): Signal {
|
|
return {
|
|
id: `sig_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
|
|
from: "agent-1",
|
|
type: "info",
|
|
content: "test",
|
|
createdAt: new Date().toISOString(),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeSession(overrides: Partial<Session> = {}): Session {
|
|
return {
|
|
id: `ses_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
|
|
project: "test",
|
|
cwd: "/tmp",
|
|
startedAt: new Date().toISOString(),
|
|
status: "active",
|
|
observationCount: 0,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeMemory(overrides: Partial<Memory> = {}): Memory {
|
|
return {
|
|
id: `mem_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
type: "fact",
|
|
title: "Test memory",
|
|
content: "content",
|
|
concepts: [],
|
|
files: [],
|
|
sessionIds: [],
|
|
strength: 1,
|
|
version: 1,
|
|
isLatest: true,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makePeer(overrides: Partial<MeshPeer> = {}): MeshPeer {
|
|
return {
|
|
id: `peer_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
|
|
url: "http://localhost:3111",
|
|
name: "Test peer",
|
|
status: "connected",
|
|
sharedScopes: [],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe("Diagnostics Functions", () => {
|
|
let sdk: ReturnType<typeof mockSdk>;
|
|
let kv: ReturnType<typeof mockKV>;
|
|
|
|
beforeEach(() => {
|
|
sdk = mockSdk();
|
|
kv = mockKV();
|
|
registerDiagnosticsFunction(sdk as never, kv as never);
|
|
});
|
|
|
|
describe("mem::diagnose", () => {
|
|
it("empty system passes all checks", async () => {
|
|
const result = (await sdk.trigger("mem::diagnose", {})) as {
|
|
success: boolean;
|
|
checks: DiagnosticCheck[];
|
|
summary: { pass: number; warn: number; fail: number; fixable: number };
|
|
};
|
|
|
|
expect(result.success).toBe(true);
|
|
// 15 = 8 original (actions, leases, sentinels, sketches, signals,
|
|
// sessions, memories, mesh) + 6 added in #lesson-visibility
|
|
// (lessons, summaries, semantic, procedural, crystals, insights) +
|
|
// 1 added in #memory-project-scope (memory-project-coverage).
|
|
expect(result.summary.pass).toBe(15);
|
|
expect(result.summary.warn).toBe(0);
|
|
expect(result.summary.fail).toBe(0);
|
|
expect(result.summary.fixable).toBe(0);
|
|
expect(result.checks.every((c) => c.status === "pass")).toBe(true);
|
|
});
|
|
|
|
it("active action with no lease produces warn", async () => {
|
|
const action = makeAction({ status: "active" });
|
|
await kv.set(KV.actions, action.id, action);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["actions"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("active-no-lease:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("warn");
|
|
expect(check!.fixable).toBe(false);
|
|
});
|
|
|
|
it("blocked action with all deps done produces fail (fixable)", async () => {
|
|
const dep = makeAction({ status: "done" });
|
|
const blocked = makeAction({ status: "blocked" });
|
|
const edge = makeEdge({
|
|
sourceActionId: blocked.id,
|
|
targetActionId: dep.id,
|
|
type: "requires",
|
|
});
|
|
await kv.set(KV.actions, dep.id, dep);
|
|
await kv.set(KV.actions, blocked.id, blocked);
|
|
await kv.set(KV.actionEdges, edge.id, edge);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["actions"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("blocked-deps-done:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("fail");
|
|
expect(check!.fixable).toBe(true);
|
|
});
|
|
|
|
it("pending action with unsatisfied deps produces fail (fixable)", async () => {
|
|
const dep = makeAction({ status: "active" });
|
|
const pending = makeAction({ status: "pending" });
|
|
const edge = makeEdge({
|
|
sourceActionId: pending.id,
|
|
targetActionId: dep.id,
|
|
type: "requires",
|
|
});
|
|
await kv.set(KV.actions, dep.id, dep);
|
|
await kv.set(KV.actions, pending.id, pending);
|
|
await kv.set(KV.actionEdges, edge.id, edge);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["actions"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("pending-unsatisfied-deps:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("fail");
|
|
expect(check!.fixable).toBe(true);
|
|
});
|
|
|
|
it("expired active lease produces fail (fixable)", async () => {
|
|
const action = makeAction({ status: "active" });
|
|
const lease = makeLease({
|
|
actionId: action.id,
|
|
status: "active",
|
|
expiresAt: new Date(Date.now() - 60_000).toISOString(),
|
|
});
|
|
await kv.set(KV.actions, action.id, action);
|
|
await kv.set(KV.leases, lease.id, lease);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["leases"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("expired-lease:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("fail");
|
|
expect(check!.fixable).toBe(true);
|
|
});
|
|
|
|
it("orphaned lease (action gone) produces fail (fixable)", async () => {
|
|
const lease = makeLease({
|
|
actionId: "act_gone",
|
|
status: "active",
|
|
expiresAt: new Date(Date.now() + 60_000).toISOString(),
|
|
});
|
|
await kv.set(KV.leases, lease.id, lease);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["leases"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("orphaned-lease:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("fail");
|
|
expect(check!.fixable).toBe(true);
|
|
});
|
|
|
|
it("expired watching sentinel produces fail (fixable)", async () => {
|
|
const sentinel = makeSentinel({
|
|
status: "watching",
|
|
expiresAt: new Date(Date.now() - 60_000).toISOString(),
|
|
});
|
|
await kv.set(KV.sentinels, sentinel.id, sentinel);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["sentinels"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("expired-sentinel:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("fail");
|
|
expect(check!.fixable).toBe(true);
|
|
});
|
|
|
|
it("sentinel referencing missing action produces warn", async () => {
|
|
const sentinel = makeSentinel({
|
|
linkedActionIds: ["act_nonexistent"],
|
|
});
|
|
await kv.set(KV.sentinels, sentinel.id, sentinel);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["sentinels"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("sentinel-missing-action:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("warn");
|
|
expect(check!.fixable).toBe(false);
|
|
});
|
|
|
|
it("expired active sketch produces fail (fixable)", async () => {
|
|
const sketch = makeSketch({
|
|
status: "active",
|
|
expiresAt: new Date(Date.now() - 60_000).toISOString(),
|
|
});
|
|
await kv.set(KV.sketches, sketch.id, sketch);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["sketches"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("expired-sketch:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("fail");
|
|
expect(check!.fixable).toBe(true);
|
|
});
|
|
|
|
it("expired signal produces fail (fixable)", async () => {
|
|
const signal = makeSignal({
|
|
expiresAt: new Date(Date.now() - 60_000).toISOString(),
|
|
});
|
|
await kv.set(KV.signals, signal.id, signal);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["signals"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("expired-signal:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("fail");
|
|
expect(check!.fixable).toBe(true);
|
|
});
|
|
|
|
it("active session older than 24h produces warn", async () => {
|
|
const session = makeSession({
|
|
status: "active",
|
|
startedAt: new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString(),
|
|
});
|
|
await kv.set(KV.sessions, session.id, session);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["sessions"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("abandoned-session:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("warn");
|
|
expect(check!.fixable).toBe(false);
|
|
});
|
|
|
|
it("memory with stale isLatest produces fail (fixable)", async () => {
|
|
const oldMemory = makeMemory({ isLatest: true });
|
|
const newMemory = makeMemory({ supersedes: [oldMemory.id] });
|
|
await kv.set(KV.memories, oldMemory.id, oldMemory);
|
|
await kv.set(KV.memories, newMemory.id, newMemory);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["memories"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("memory-stale-latest:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("fail");
|
|
expect(check!.fixable).toBe(true);
|
|
});
|
|
|
|
it("memory superseding non-existent produces warn", async () => {
|
|
const memory = makeMemory({ supersedes: ["mem_gone"] });
|
|
await kv.set(KV.memories, memory.id, memory);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["memories"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("memory-missing-supersedes:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("warn");
|
|
expect(check!.fixable).toBe(false);
|
|
});
|
|
|
|
it("stale mesh peer produces warn", async () => {
|
|
const peer = makePeer({
|
|
lastSyncAt: new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString(),
|
|
});
|
|
await kv.set(KV.mesh, peer.id, peer);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["mesh"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("stale-peer:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("warn");
|
|
expect(check!.fixable).toBe(false);
|
|
});
|
|
|
|
it("error mesh peer produces warn", async () => {
|
|
const peer = makePeer({ status: "error" });
|
|
await kv.set(KV.mesh, peer.id, peer);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["mesh"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const check = result.checks.find((c) =>
|
|
c.name.startsWith("error-peer:"),
|
|
);
|
|
expect(check).toBeDefined();
|
|
expect(check!.status).toBe("warn");
|
|
expect(check!.fixable).toBe(false);
|
|
});
|
|
|
|
it("filters by categories", async () => {
|
|
const action = makeAction({ status: "active" });
|
|
await kv.set(KV.actions, action.id, action);
|
|
|
|
const signal = makeSignal({
|
|
expiresAt: new Date(Date.now() - 60_000).toISOString(),
|
|
});
|
|
await kv.set(KV.signals, signal.id, signal);
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["signals"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
expect(result.checks.every((c) => c.category === "signals")).toBe(true);
|
|
expect(
|
|
result.checks.some((c) => c.category === "actions"),
|
|
).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("mem::heal", () => {
|
|
it("unblocks stuck blocked action", async () => {
|
|
const dep = makeAction({ status: "done" });
|
|
const blocked = makeAction({ status: "blocked", title: "Stuck task" });
|
|
const edge = makeEdge({
|
|
sourceActionId: blocked.id,
|
|
targetActionId: dep.id,
|
|
type: "requires",
|
|
});
|
|
await kv.set(KV.actions, dep.id, dep);
|
|
await kv.set(KV.actions, blocked.id, blocked);
|
|
await kv.set(KV.actionEdges, edge.id, edge);
|
|
|
|
const result = (await sdk.trigger("mem::heal", {
|
|
categories: ["actions"],
|
|
})) as { success: boolean; fixed: number; details: string[] };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.fixed).toBe(1);
|
|
expect(result.details[0]).toContain("Unblocked");
|
|
|
|
const updated = await kv.get<Action>(KV.actions, blocked.id);
|
|
expect(updated!.status).toBe("pending");
|
|
});
|
|
|
|
it("blocks pending action with unsatisfied deps", async () => {
|
|
const dep = makeAction({ status: "active" });
|
|
const pending = makeAction({
|
|
status: "pending",
|
|
title: "Should be blocked",
|
|
});
|
|
const edge = makeEdge({
|
|
sourceActionId: pending.id,
|
|
targetActionId: dep.id,
|
|
type: "requires",
|
|
});
|
|
await kv.set(KV.actions, dep.id, dep);
|
|
await kv.set(KV.actions, pending.id, pending);
|
|
await kv.set(KV.actionEdges, edge.id, edge);
|
|
|
|
const result = (await sdk.trigger("mem::heal", {
|
|
categories: ["actions"],
|
|
})) as { success: boolean; fixed: number; details: string[] };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.fixed).toBe(1);
|
|
expect(result.details[0]).toContain("Blocked");
|
|
|
|
const updated = await kv.get<Action>(KV.actions, pending.id);
|
|
expect(updated!.status).toBe("blocked");
|
|
});
|
|
|
|
it("expires stale lease and resets action", async () => {
|
|
const action = makeAction({
|
|
status: "active",
|
|
assignedTo: "agent-1",
|
|
});
|
|
const lease = makeLease({
|
|
actionId: action.id,
|
|
agentId: "agent-1",
|
|
status: "active",
|
|
expiresAt: new Date(Date.now() - 60_000).toISOString(),
|
|
});
|
|
await kv.set(KV.actions, action.id, action);
|
|
await kv.set(KV.leases, lease.id, lease);
|
|
|
|
const result = (await sdk.trigger("mem::heal", {
|
|
categories: ["leases"],
|
|
})) as { success: boolean; fixed: number; details: string[] };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.fixed).toBe(1);
|
|
expect(result.details[0]).toContain("Expired lease");
|
|
|
|
const updatedLease = await kv.get<Lease>(KV.leases, lease.id);
|
|
expect(updatedLease!.status).toBe("expired");
|
|
|
|
const updatedAction = await kv.get<Action>(KV.actions, action.id);
|
|
expect(updatedAction!.status).toBe("pending");
|
|
expect(updatedAction!.assignedTo).toBeUndefined();
|
|
});
|
|
|
|
it("deletes orphaned lease", async () => {
|
|
const lease = makeLease({
|
|
actionId: "act_gone",
|
|
status: "released",
|
|
expiresAt: new Date(Date.now() + 60_000).toISOString(),
|
|
});
|
|
await kv.set(KV.leases, lease.id, lease);
|
|
|
|
const result = (await sdk.trigger("mem::heal", {
|
|
categories: ["leases"],
|
|
})) as { success: boolean; fixed: number; details: string[] };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.fixed).toBe(1);
|
|
expect(result.details[0]).toContain("Deleted orphaned lease");
|
|
|
|
const deleted = await kv.get<Lease>(KV.leases, lease.id);
|
|
expect(deleted).toBeNull();
|
|
});
|
|
|
|
it("expires stale sentinel", async () => {
|
|
const sentinel = makeSentinel({
|
|
status: "watching",
|
|
name: "Stale watcher",
|
|
expiresAt: new Date(Date.now() - 60_000).toISOString(),
|
|
});
|
|
await kv.set(KV.sentinels, sentinel.id, sentinel);
|
|
|
|
const result = (await sdk.trigger("mem::heal", {
|
|
categories: ["sentinels"],
|
|
})) as { success: boolean; fixed: number; details: string[] };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.fixed).toBe(1);
|
|
expect(result.details[0]).toContain("Expired sentinel");
|
|
|
|
const updated = await kv.get<Sentinel>(KV.sentinels, sentinel.id);
|
|
expect(updated!.status).toBe("expired");
|
|
});
|
|
|
|
it("dry run reports but does not fix", async () => {
|
|
const dep = makeAction({ status: "done" });
|
|
const blocked = makeAction({ status: "blocked", title: "Stuck task" });
|
|
const edge = makeEdge({
|
|
sourceActionId: blocked.id,
|
|
targetActionId: dep.id,
|
|
type: "requires",
|
|
});
|
|
await kv.set(KV.actions, dep.id, dep);
|
|
await kv.set(KV.actions, blocked.id, blocked);
|
|
await kv.set(KV.actionEdges, edge.id, edge);
|
|
|
|
const result = (await sdk.trigger("mem::heal", {
|
|
categories: ["actions"],
|
|
dryRun: true,
|
|
})) as { success: boolean; fixed: number; details: string[] };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.fixed).toBe(1);
|
|
expect(result.details[0]).toContain("[dry-run]");
|
|
|
|
const unchanged = await kv.get<Action>(KV.actions, blocked.id);
|
|
expect(unchanged!.status).toBe("blocked");
|
|
});
|
|
});
|
|
|
|
describe("per-store tally categories (#lesson-visibility)", () => {
|
|
it("lessons category: passes with valid live lessons + ignores tombstoned", async () => {
|
|
await kv.set(KV.lessons, "lsn_live", {
|
|
id: "lsn_live", content: "x", context: "", confidence: 0.8,
|
|
reinforcements: 0, source: "manual", sourceIds: [], tags: [],
|
|
createdAt: "", updatedAt: "", decayRate: 0.05,
|
|
});
|
|
await kv.set(KV.lessons, "lsn_tomb", {
|
|
id: "lsn_tomb", content: "x", context: "", confidence: 0.5,
|
|
reinforcements: 0, source: "manual", sourceIds: [], tags: [],
|
|
createdAt: "", updatedAt: "", decayRate: 0.05, deleted: true,
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["lessons"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const ok = result.checks.find((c) => c.name === "lessons-ok");
|
|
expect(ok?.status).toBe("pass");
|
|
expect(ok?.message).toMatch(/All 1 lessons.*1 tombstoned/);
|
|
});
|
|
|
|
it("lessons category: warns on out-of-range confidence", async () => {
|
|
await kv.set(KV.lessons, "lsn_bad", {
|
|
id: "lsn_bad", content: "x", context: "", confidence: 1.5,
|
|
reinforcements: 0, source: "manual", sourceIds: [], tags: [],
|
|
createdAt: "", updatedAt: "", decayRate: 0.05,
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["lessons"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const warn = result.checks.find((c) => c.name.startsWith("lesson-bad-confidence:"));
|
|
expect(warn?.status).toBe("warn");
|
|
});
|
|
|
|
it("summaries category: warns on missing title", async () => {
|
|
await kv.set(KV.summaries, "ses_1", {
|
|
sessionId: "ses_1", project: "p", createdAt: "", title: "",
|
|
narrative: "n", keyDecisions: [], filesModified: [], concepts: [],
|
|
observationCount: 1,
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["summaries"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const warn = result.checks.find((c) => c.name.startsWith("summary-missing-title:"));
|
|
expect(warn?.status).toBe("warn");
|
|
});
|
|
|
|
it("procedural category: warns on empty steps", async () => {
|
|
await kv.set(KV.procedural, "proc_1", {
|
|
id: "proc_1", name: "noop", steps: [], triggerCondition: "x",
|
|
frequency: 1, sourceSessionIds: [], strength: 0.5,
|
|
createdAt: "", updatedAt: "",
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["procedural"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const warn = result.checks.find((c) => c.name.startsWith("procedural-empty-steps:"));
|
|
expect(warn?.status).toBe("warn");
|
|
});
|
|
|
|
it("crystals category: warns on empty narrative", async () => {
|
|
await kv.set(KV.crystals, "cry_1", {
|
|
id: "cry_1", narrative: "", keyOutcomes: [], filesAffected: [],
|
|
lessons: [], sourceActionIds: [], createdAt: "",
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["crystals"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const warn = result.checks.find((c) => c.name.startsWith("crystal-empty-narrative:"));
|
|
expect(warn?.status).toBe("warn");
|
|
});
|
|
|
|
it("insights category: warns on out-of-range confidence", async () => {
|
|
await kv.set(KV.insights, "ins_bad", {
|
|
id: "ins_bad", title: "t", content: "c", confidence: -0.1,
|
|
reinforcements: 0, sourceConceptCluster: [], sourceMemoryIds: [],
|
|
sourceLessonIds: [], sourceCrystalIds: [], tags: [],
|
|
createdAt: "", updatedAt: "", decayRate: 0.05,
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["insights"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const warn = result.checks.find((c) => c.name.startsWith("insight-bad-confidence:"));
|
|
expect(warn?.status).toBe("warn");
|
|
});
|
|
|
|
it("semantic category: warns on out-of-range confidence", async () => {
|
|
await kv.set(KV.semantic, "sem_bad", {
|
|
id: "sem_bad", fact: "f", confidence: 2.0, sourceSessionIds: [],
|
|
sourceMemoryIds: [], accessCount: 0, lastAccessedAt: "",
|
|
strength: 0, createdAt: "", updatedAt: "",
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["semantic"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const warn = result.checks.find((c) => c.name.startsWith("semantic-bad-confidence:"));
|
|
expect(warn?.status).toBe("warn");
|
|
});
|
|
|
|
it("categories filter accepts new categories and skips others", async () => {
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["lessons", "summaries"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
expect(result.checks.every((c) => c.category === "lessons" || c.category === "summaries")).toBe(true);
|
|
expect(result.checks.some((c) => c.category === "lessons")).toBe(true);
|
|
expect(result.checks.some((c) => c.category === "summaries")).toBe(true);
|
|
});
|
|
|
|
describe("defensive row-shape handling (CodeRabbit #473 review)", () => {
|
|
it("NaN/Infinity confidence on a lesson is flagged as warn, not silently passed", async () => {
|
|
await kv.set(KV.lessons, "lsn_nan", {
|
|
id: "lsn_nan", content: "x", context: "", confidence: NaN,
|
|
reinforcements: 0, source: "manual", sourceIds: [], tags: [],
|
|
createdAt: "", updatedAt: "", decayRate: 0.05,
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["lessons"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
const warn = result.checks.find((c) => c.name.startsWith("lesson-bad-confidence:"));
|
|
expect(warn?.status).toBe("warn");
|
|
});
|
|
|
|
it("non-string summary title doesn't throw — surfaces as warn", async () => {
|
|
await kv.set(KV.summaries, "ses_bad_title", {
|
|
sessionId: "ses_bad_title",
|
|
project: "p",
|
|
createdAt: "",
|
|
title: null as unknown as string, // simulate corrupted row
|
|
narrative: "n",
|
|
keyDecisions: [],
|
|
filesModified: [],
|
|
concepts: [],
|
|
observationCount: 1,
|
|
});
|
|
|
|
// The bug to guard against: the old code called .trim() unconditionally,
|
|
// which throws on null/number, which aborts the whole diagnose run and
|
|
// any later category check never executes. Verify diagnose completes
|
|
// AND surfaces the bad row.
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["summaries", "lessons"],
|
|
})) as { checks: DiagnosticCheck[]; success?: boolean };
|
|
|
|
expect(result.success).toBe(true);
|
|
const warn = result.checks.find((c) => c.name.startsWith("summary-missing-title:"));
|
|
expect(warn?.status).toBe("warn");
|
|
// Later category still ran:
|
|
expect(result.checks.some((c) => c.category === "lessons")).toBe(true);
|
|
});
|
|
|
|
it("non-string crystal narrative doesn't throw — surfaces as warn", async () => {
|
|
await kv.set(KV.crystals, "cry_bad", {
|
|
id: "cry_bad",
|
|
narrative: undefined as unknown as string,
|
|
keyOutcomes: [],
|
|
filesAffected: [],
|
|
lessons: [],
|
|
sourceActionIds: [],
|
|
createdAt: "",
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["crystals"],
|
|
})) as { checks: DiagnosticCheck[]; success?: boolean };
|
|
|
|
expect(result.success).toBe(true);
|
|
const warn = result.checks.find((c) => c.name.startsWith("crystal-empty-narrative:"));
|
|
expect(warn?.status).toBe("warn");
|
|
});
|
|
|
|
it("Infinity confidence on insight + semantic both flagged", async () => {
|
|
await kv.set(KV.insights, "ins_inf", {
|
|
id: "ins_inf",
|
|
title: "t",
|
|
content: "c",
|
|
confidence: Infinity,
|
|
reinforcements: 0,
|
|
sourceConceptCluster: [],
|
|
sourceMemoryIds: [],
|
|
sourceLessonIds: [],
|
|
sourceCrystalIds: [],
|
|
tags: [],
|
|
createdAt: "",
|
|
updatedAt: "",
|
|
decayRate: 0.05,
|
|
});
|
|
await kv.set(KV.semantic, "sem_nan", {
|
|
id: "sem_nan",
|
|
fact: "f",
|
|
confidence: NaN,
|
|
sourceSessionIds: [],
|
|
sourceMemoryIds: [],
|
|
accessCount: 0,
|
|
lastAccessedAt: "",
|
|
strength: 0,
|
|
createdAt: "",
|
|
updatedAt: "",
|
|
});
|
|
|
|
const result = (await sdk.trigger("mem::diagnose", {
|
|
categories: ["insights", "semantic"],
|
|
})) as { checks: DiagnosticCheck[] };
|
|
|
|
expect(result.checks.find((c) => c.name === "insight-bad-confidence:ins_inf")?.status).toBe("warn");
|
|
expect(result.checks.find((c) => c.name === "semantic-bad-confidence:sem_nan")?.status).toBe("warn");
|
|
});
|
|
});
|
|
});
|
|
});
|