@haaaiawd/second-nature 0.1.50 → 0.1.51

package/dist/tests/unit/cli/t1-2-4-goal-command.test.js

@@ -1,207 +0,0 @@
-/**
- * Unit coverage for `goalCommand` (T1.2.4).
- *
- * Verifies set/list/accept/reject operations, status transitions,
- * missing-input errors, state-unavailable path, and before/after state.
- */
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { createStateDatabase } from "../../../src/storage/db/index.js";
-import { goalCommand } from "../../../src/cli/commands/goal.js";
-function tmpDb() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-goal-test-"));
-    const dbPath = path.join(dir, "test.db");
-    const db = createStateDatabase(dbPath);
-    return {
-        db,
-        cleanup: () => {
-            db.close();
-            fs.rmSync(dir, { recursive: true, force: true });
-        },
-    };
-}
-test("T1.2.4 goal set creates owner-set accepted goal with before/after", async () => {
-    const { db, cleanup } = tmpDb();
-    const result = await goalCommand(db, {
-        action: "set",
-        description: "完善 EvoMap profile",
-        completionCriteria: "profile 完整度 > 80%",
-        risk: "low",
-        kind: "short_term",
-    });
-    assert.equal(result.ok, true);
-    assert.equal(result.action, "set");
-    const data = result.data;
-    const goal = data.goal;
-    assert.equal(goal.status, "accepted");
-    assert.equal(goal.origin, "owner_set");
-    assert.equal(goal.acceptedBy, "owner");
-    assert.equal(goal.description, "完善 EvoMap profile");
-    assert.equal(goal.completionCriteria, "profile 完整度 > 80%");
-    const after = data.after;
-    assert.equal(after.status, "accepted");
-    assert.equal(after.origin, "owner_set");
-    cleanup();
-});
-test("T1.2.4 goal set without description returns missing error", async () => {
-    const { db, cleanup } = tmpDb();
-    const result = await goalCommand(db, { action: "set", description: "" });
-    assert.equal(result.ok, false);
-    assert.equal(result.error?.code, "MISSING_DESCRIPTION");
-    cleanup();
-});
-test("T1.2.4 goal list returns created goals", async () => {
-    const { db, cleanup } = tmpDb();
-    await goalCommand(db, {
-        action: "set",
-        description: "Goal A",
-        completionCriteria: "criteria A",
-    });
-    await goalCommand(db, {
-        action: "set",
-        description: "Goal B",
-        completionCriteria: "criteria B",
-        kind: "long_term",
-        risk: "medium",
-    });
-    const result = await goalCommand(db, { action: "list" });
-    assert.equal(result.ok, true);
-    const data = result.data;
-    assert.equal(data.total, 2);
-    const goals = data.goals;
-    assert.equal(goals.length, 2);
-    assert.ok(goals.some((g) => g.description === "Goal A"));
-    assert.ok(goals.some((g) => g.description === "Goal B"));
-    cleanup();
-});
-test("T1.2.4 goal list filters by status and origin", async () => {
-    const { db, cleanup } = tmpDb();
-    // Create an accepted owner-set goal
-    await goalCommand(db, {
-        action: "set",
-        description: "Accepted goal",
-    });
-    // Create a proposal goal manually
-    const store = (await import("../../../src/storage/goal/agent-goal-store.js")).createAgentGoalStore(db);
-    await store.upsertAgentGoal({
-        goalId: "proposal-1",
-        kind: "short_term",
-        status: "proposal",
-        origin: "agent_proposed",
-        description: "Proposed goal",
-        completionCriteria: "",
-        risk: "low",
-        priorityHint: 0,
-        sourceRefs: [],
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-    });
-    const acceptedResult = await goalCommand(db, { action: "list", statusFilter: "accepted" });
-    const acceptedData = acceptedResult.data;
-    assert.equal(acceptedData.total, 1);
-    const proposalResult = await goalCommand(db, { action: "list", statusFilter: "proposal" });
-    const proposalData = proposalResult.data;
-    assert.equal(proposalData.total, 1);
-    cleanup();
-});
-test("T1.2.4 goal accept transitions proposal to accepted with before/after", async () => {
-    const { db, cleanup } = tmpDb();
-    const store = (await import("../../../src/storage/goal/agent-goal-store.js")).createAgentGoalStore(db);
-    await store.upsertAgentGoal({
-        goalId: "test-proposal",
-        kind: "short_term",
-        status: "proposal",
-        origin: "agent_proposed",
-        description: "Agent proposed goal",
-        completionCriteria: "",
-        risk: "low",
-        priorityHint: 0,
-        sourceRefs: [],
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-    });
-    const result = await goalCommand(db, {
-        action: "accept",
-        goalId: "test-proposal",
-    });
-    assert.equal(result.ok, true);
-    const data = result.data;
-    const before = data.before;
-    const after = data.after;
-    assert.equal(before.status, "proposal");
-    assert.equal(after.status, "accepted");
-    assert.equal(after.acceptedBy, "owner");
-    cleanup();
-});
-test("T1.2.4 goal accept non-proposal returns invalid transition error", async () => {
-    const { db, cleanup } = tmpDb();
-    await goalCommand(db, {
-        action: "set",
-        description: "Already accepted",
-        goalId: "already-accepted",
-    });
-    const result = await goalCommand(db, {
-        action: "accept",
-        goalId: "already-accepted",
-    });
-    assert.equal(result.ok, false);
-    assert.equal(result.error?.code, "INVALID_STATUS_TRANSITION");
-    cleanup();
-});
-test("T1.2.4 goal reject transitions proposal to rejected with before/after", async () => {
-    const { db, cleanup } = tmpDb();
-    const store = (await import("../../../src/storage/goal/agent-goal-store.js")).createAgentGoalStore(db);
-    await store.upsertAgentGoal({
-        goalId: "test-reject",
-        kind: "short_term",
-        status: "proposal",
-        origin: "agent_proposed",
-        description: "Reject me",
-        completionCriteria: "",
-        risk: "low",
-        priorityHint: 0,
-        sourceRefs: [],
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-    });
-    const result = await goalCommand(db, {
-        action: "reject",
-        goalId: "test-reject",
-    });
-    assert.equal(result.ok, true);
-    const data = result.data;
-    const before = data.before;
-    const after = data.after;
-    assert.equal(before.status, "proposal");
-    assert.equal(after.status, "rejected");
-    cleanup();
-});
-test("T1.2.4 goal accept missing goalId returns error", async () => {
-    const { db, cleanup } = tmpDb();
-    const result = await goalCommand(db, { action: "accept" });
-    assert.equal(result.ok, false);
-    assert.equal(result.error?.code, "MISSING_GOAL_ID");
-    cleanup();
-});
-test("T1.2.4 goal accept unknown goalId returns not found", async () => {
-    const { db, cleanup } = tmpDb();
-    const result = await goalCommand(db, { action: "accept", goalId: "unknown" });
-    assert.equal(result.ok, false);
-    assert.equal(result.error?.code, "GOAL_NOT_FOUND");
-    cleanup();
-});
-test("T1.2.4 goal command without state returns STATE_UNAVAILABLE", async () => {
-    const result = await goalCommand(undefined, { action: "list" });
-    assert.equal(result.ok, false);
-    assert.equal(result.error?.code, "STATE_UNAVAILABLE");
-});
-test("T1.2.4 goal command unknown action returns error", async () => {
-    const { db, cleanup } = tmpDb();
-    const result = await goalCommand(db, { action: "delete" });
-    assert.equal(result.ok, false);
-    assert.equal(result.error?.code, "UNKNOWN_GOAL_ACTION");
-    cleanup();
-});

package/dist/tests/unit/cli/t1-3-1-connector-init.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/unit/cli/t1-3-1-connector-init.test.js

@@ -1,212 +0,0 @@
-/**
- * Unit coverage for `connectorInit` (T1.3.1).
- *
- * Verifies manifest + adapter.ts + types.ts generation, path safety,
- * overwrite refusal (fail-closed), force overwrite, platformId sanitization,
- * baseUrl propagation, and default values.
- */
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { connectorInit, } from "../../../src/cli/commands/connector-init.js";
-import { connectorBehaviorAdd } from "../../../src/cli/commands/connector-behavior.js";
-function tmpDir() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), "sn-connector-init-"));
-}
-test("T1.3.1 creates manifest.yaml + adapter.ts + types.ts in .second-nature/connectors/{platformId}/", async () => {
-    const root = tmpDir();
-    const result = await connectorInit({
-        platformId: "testplat",
-        workspaceRoot: root,
-    });
-    assert.equal(result.ok, true);
-    assert.equal(result.created, true);
-    assert.equal(result.platformId, "testplat");
-    const platformDir = path.join(root, ".second-nature", "connectors", "testplat");
-    const manifestPath = path.join(platformDir, "manifest.yaml");
-    const adapterPath = path.join(platformDir, "adapter.ts");
-    const typesPath = path.join(platformDir, "types.ts");
-    assert.equal(result.manifestPath, manifestPath);
-    assert.equal(result.adapterPath, adapterPath);
-    assert.equal(result.typesPath, typesPath);
-    assert.ok(fs.existsSync(manifestPath), "manifest.yaml must exist");
-    assert.ok(fs.existsSync(adapterPath), "adapter.ts must exist");
-    assert.ok(fs.existsSync(typesPath), "types.ts must exist");
-    const manifestContent = fs.readFileSync(manifestPath, "utf-8");
-    assert.ok(manifestContent.includes("schemaVersion: sn.connector.v1"));
-    assert.ok(manifestContent.includes("platformId: testplat"));
-    assert.ok(manifestContent.includes("family: custom"));
-    assert.ok(manifestContent.includes("kind: declarative_http"));
-    const adapterContent = fs.readFileSync(adapterPath, "utf-8");
-    assert.ok(adapterContent.includes("Testplat Connector Adapter Stub"));
-    assert.ok(adapterContent.includes("interface TestplatAdapterConfig"));
-    assert.ok(adapterContent.includes("executeTestplatAction"));
-    const typesContent = fs.readFileSync(typesPath, "utf-8");
-    assert.ok(typesContent.includes("interface TestplatCapability"));
-    assert.ok(typesContent.includes("interface TestplatCredential"));
-    fs.rmSync(root, { recursive: true });
-});
-test("T1.3.1 returns fail-closed when manifest already exists without force", async () => {
-    const root = tmpDir();
-    const first = await connectorInit({
-        platformId: "dupe",
-        workspaceRoot: root,
-    });
-    assert.equal(first.created, true);
-    const second = await connectorInit({
-        platformId: "dupe",
-        workspaceRoot: root,
-    });
-    // CR7-01: existing target must return ok:false (not ok:true skipped)
-    assert.equal(second.ok, false);
-    assert.equal(second.created, false);
-    assert.ok(second.reason?.includes("force"));
-    fs.rmSync(root, { recursive: true });
-});
-test("T1.3.1 force:true overwrites existing manifest and stubs", async () => {
-    const root = tmpDir();
-    await connectorInit({
-        platformId: "forceme",
-        workspaceRoot: root,
-    });
-    const result = await connectorInit({
-        platformId: "forceme",
-        workspaceRoot: root,
-        force: true,
-        displayName: "Forced Display",
-    });
-    assert.equal(result.ok, true);
-    assert.equal(result.created, true);
-    const manifestPath = path.join(root, ".second-nature", "connectors", "forceme", "manifest.yaml");
-    const content = fs.readFileSync(manifestPath, "utf-8");
-    assert.ok(content.includes("displayName: Forced Display"));
-    fs.rmSync(root, { recursive: true });
-});
-test("T1.3.1 rejects empty platformId", async () => {
-    const result = await connectorInit({ platformId: "" });
-    assert.equal(result.ok, false);
-    assert.ok(result.reason?.includes("platformId"));
-});
-test("T1.3.1 rejects platformId with invalid characters", async () => {
-    const result = await connectorInit({ platformId: "my/platform" });
-    assert.equal(result.ok, false);
-    assert.ok(result.reason?.includes("invalid characters"));
-});
-test("T1.3.1 rejects dot and dot-dot platformId (path escape guard)", async () => {
-    const dot = await connectorInit({ platformId: "." });
-    assert.equal(dot.ok, false);
-    assert.ok(dot.reason?.includes("cannot be"));
-    const dotdot = await connectorInit({ platformId: ".." });
-    assert.equal(dotdot.ok, false);
-    assert.ok(dotdot.reason?.includes("cannot be"));
-});
-test("T1.3.1 uses custom family, runnerKind, and baseUrl when provided", async () => {
-    const root = tmpDir();
-    const result = await connectorInit({
-        platformId: "customplat",
-        family: "social_community",
-        runnerKind: "skill",
-        displayName: "Custom Plat",
-        baseUrl: "https://example.com/api",
-        workspaceRoot: root,
-    });
-    assert.equal(result.ok, true);
-    const manifestPath = path.join(root, ".second-nature", "connectors", "customplat", "manifest.yaml");
-    const content = fs.readFileSync(manifestPath, "utf-8");
-    assert.ok(content.includes("family: social_community"));
-    assert.ok(content.includes("kind: skill"));
-    assert.ok(content.includes("displayName: Custom Plat"));
-    assert.ok(content.includes("baseUrl: https://example.com/api"));
-    fs.rmSync(root, { recursive: true });
-});
-test("T1.3.1 generated manifest has custom_adapter_pending_trust and executable=false after scan", async () => {
-    const root = tmpDir();
-    await connectorInit({
-        platformId: "agent-world",
-        runnerKind: "custom_adapter",
-        workspaceRoot: root,
-    });
-    const manifestPath = path.join(root, ".second-nature", "connectors", "agent-world", "manifest.yaml");
-    const content = fs.readFileSync(manifestPath, "utf-8");
-    assert.ok(content.includes("status: custom_adapter_pending_trust"));
-    assert.ok(content.includes("reason: generated_by_connector_init"));
-    fs.rmSync(root, { recursive: true });
-});
-test("connector_behavior_add appends a custom behavior to an existing manifest", async () => {
-    const root = tmpDir();
-    await connectorInit({
-        platformId: "github",
-        workspaceRoot: root,
-    });
-    const result = await connectorBehaviorAdd({
-        platformId: "github",
-        behaviorId: "issue.search",
-        description: "Search issues before deciding whether to comment",
-        workspaceRoot: root,
-    });
-    assert.equal(result.ok, true);
-    assert.equal(result.added, true);
-    const manifestPath = path.join(root, ".second-nature", "connectors", "github", "manifest.yaml");
-    const content = fs.readFileSync(manifestPath, "utf-8");
-    assert.ok(content.includes("id: issue.search"));
-    assert.ok(content.includes("Search issues before deciding whether to comment"));
-    const second = await connectorBehaviorAdd({
-        platformId: "github",
-        behaviorId: "issue.search",
-        workspaceRoot: root,
-    });
-    assert.equal(second.ok, true);
-    assert.equal(second.added, false);
-    fs.rmSync(root, { recursive: true });
-});
-test("connector_behavior_add requires a reviewable motive for new behaviors", async () => {
-    const root = tmpDir();
-    await connectorInit({
-        platformId: "github",
-        workspaceRoot: root,
-    });
-    const result = await connectorBehaviorAdd({
-        platformId: "github",
-        behaviorId: "issue.search",
-        workspaceRoot: root,
-    });
-    assert.equal(result.ok, false);
-    assert.equal(result.added, false);
-    assert.match(result.reason ?? "", /description or sourceRefs is required/);
-    fs.rmSync(root, { recursive: true });
-});
-test("connector_behavior_add records source refs and observed count", async () => {
-    const root = tmpDir();
-    await connectorInit({
-        platformId: "github",
-        workspaceRoot: root,
-    });
-    const result = await connectorBehaviorAdd({
-        platformId: "github",
-        behaviorId: "issue.search",
-        sourceRefs: ["quiet:proposal:github-issue-search"],
-        observedCount: 2,
-        workspaceRoot: root,
-    });
-    assert.equal(result.ok, true);
-    const manifestPath = path.join(root, ".second-nature", "connectors", "github", "manifest.yaml");
-    const content = fs.readFileSync(manifestPath, "utf-8");
-    assert.ok(content.includes("sourceRefs:"));
-    assert.ok(content.includes("quiet:proposal:github-issue-search"));
-    assert.ok(content.includes("observedCount: 2"));
-    fs.rmSync(root, { recursive: true });
-});
-test("connector_behavior_add rejects unsafe platform ids", async () => {
-    const root = tmpDir();
-    const result = await connectorBehaviorAdd({
-        platformId: "..",
-        behaviorId: "issue.search",
-        workspaceRoot: root,
-    });
-    assert.equal(result.ok, false);
-    assert.equal(result.added, false);
-    assert.match(result.reason ?? "", /platformId is required/);
-    fs.rmSync(root, { recursive: true });
-});

package/dist/tests/unit/connectors/connector-manifest-and-evidence-map.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/unit/connectors/connector-manifest-and-evidence-map.test.js

@@ -1,71 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { CapabilityContractRegistry, checkConnector, describeConnector, discoverCapabilities, parseConnectorManifest, } from "../../../src/connectors/base/manifest.js";
-import { mapLifeEvidence } from "../../../src/connectors/base/map-life-evidence.js";
-test("T3.1.1 describeConnector / checkConnector / discoverCapabilities", () => {
-    const registry = new CapabilityContractRegistry();
-    const manifest = parseConnectorManifest({
-        platformId: "fixture-platform",
-        supportedCapabilities: ["feed.read", "work.discover"],
-        channelPriority: ["api_rest", "skill"],
-        credentialTypes: ["api_key"],
-        degradedChannels: ["skill"],
-        sourceRefPolicy: { minSourceRefs: 1 },
-    });
-    registry.register(manifest);
-    const described = describeConnector(registry, "fixture-platform");
-    assert.equal(described.platformId, "fixture-platform");
-    const ok = checkConnector(registry, "fixture-platform");
-    assert.equal(ok.ok, true);
-    assert.equal(ok.errors.length, 0);
-    const bad = checkConnector(registry, "missing");
-    assert.equal(bad.ok, false);
-    const disc = discoverCapabilities(registry);
-    assert.equal(disc.length, 1);
-    assert.ok(disc[0].capabilities.includes("feed.read"));
-});
-test("T3.1.1 checkConnector rejects degraded channel outside priority", () => {
-    const registry = new CapabilityContractRegistry();
-    registry.register(parseConnectorManifest({
-        platformId: "bad-degraded",
-        supportedCapabilities: ["feed.read"],
-        channelPriority: ["api_rest"],
-        credentialTypes: ["api_key"],
-        degradedChannels: ["browser"],
-    }));
-    const r = checkConnector(registry, "bad-degraded");
-    assert.equal(r.ok, false);
-    assert.ok(r.errors.some((e) => e.includes("degraded_channel_not_in_priority")));
-});
-test("T3.1.2 mapLifeEvidence maps feed.read success with items to platform_browse", () => {
-    const result = {
-        status: "success",
-        data: { items: [{ id: "p1" }, { id: "p2" }] },
-        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
-    };
-    const candidate = mapLifeEvidence({
-        platformId: "moltbook",
-        intent: "feed.read",
-        result,
-        observedAt: "2026-05-02T00:00:00.000Z",
-    });
-    assert.ok(candidate);
-    assert.equal(candidate.evidenceType, "platform_browse");
-    assert.ok(candidate.sourceRefs.length >= 1);
-});
-test("T3.1.2 mapLifeEvidence returns null for message.send", () => {
-    const result = {
-        status: "success",
-        data: { items: [{ id: "x" }] },
-        metadata: { platformId: "x", channel: "api_rest", latencyMs: 1 },
-    };
-    assert.equal(mapLifeEvidence({ platformId: "x", intent: "message.send", result, observedAt: "2026-05-02T00:00:00.000Z" }), null);
-});
-test("T3.1.2 mapLifeEvidence returns null when no extractable source refs", () => {
-    const result = {
-        status: "success",
-        data: {},
-        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
-    };
-    assert.equal(mapLifeEvidence({ platformId: "moltbook", intent: "feed.read", result, observedAt: "2026-05-02T00:00:00.000Z" }), null);
-});

package/dist/tests/unit/connectors/effect-commit-ledger-sqlite.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * EffectCommitLedger SQLite tests — T-CS.C.2
- *
- * Coverage:
- * - getOrCreateIntentCommitRecord creates on first call
- * - getOrCreateIntentCommitRecord returns existing on duplicate key
- * - markCommitted transitions state and stores outcomeRef
- * - Process restart: existing key is found and returned as existing=true
- */
-export {};

package/dist/tests/unit/connectors/effect-commit-ledger-sqlite.test.js

@@ -1,101 +0,0 @@
-/**
- * EffectCommitLedger SQLite tests — T-CS.C.2
- *
- * Coverage:
- * - getOrCreateIntentCommitRecord creates on first call
- * - getOrCreateIntentCommitRecord returns existing on duplicate key
- * - markCommitted transitions state and stores outcomeRef
- * - Process restart: existing key is found and returned as existing=true
- */
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { createStateDatabase } from "../../../src/storage/db/index.js";
-import { createEffectCommitLedgerSQLite } from "../../../src/connectors/base/effect-commit-ledger-sqlite.js";
-describe("EffectCommitLedgerSQLite", () => {
-    it("creates record on first getOrCreate", async () => {
-        const db = createStateDatabase(":memory:");
-        const ledger = createEffectCommitLedgerSQLite(db);
-        const result = await ledger.getOrCreateIntentCommitRecord({
-            decisionId: "dec-1",
-            intentId: "intent-1",
-            idempotencyKey: "idem-1",
-            effectClass: "side_effect",
-        });
-        assert.strictEqual(result.existing, false);
-        assert.strictEqual(result.record.state, "planned");
-        assert(result.record.id !== undefined);
-        db.close();
-    });
-    it("returns existing on duplicate idempotency key", async () => {
-        const db = createStateDatabase(":memory:");
-        const ledger = createEffectCommitLedgerSQLite(db);
-        await ledger.getOrCreateIntentCommitRecord({
-            decisionId: "dec-1",
-            intentId: "intent-1",
-            idempotencyKey: "idem-2",
-            effectClass: "side_effect",
-        });
-        const second = await ledger.getOrCreateIntentCommitRecord({
-            decisionId: "dec-1",
-            intentId: "intent-1",
-            idempotencyKey: "idem-2",
-            effectClass: "side_effect",
-        });
-        assert.strictEqual(second.existing, true);
-        assert.strictEqual(second.record.state, "planned");
-        db.close();
-    });
-    it("markCommitted transitions state and stores outcomeRef", async () => {
-        const db = createStateDatabase(":memory:");
-        const ledger = createEffectCommitLedgerSQLite(db);
-        await ledger.getOrCreateIntentCommitRecord({
-            decisionId: "dec-1",
-            intentId: "intent-1",
-            idempotencyKey: "idem-3",
-            effectClass: "side_effect",
-        });
-        const commit = await ledger.markCommitted("idem-3", "outcome://ref-1");
-        assert.strictEqual(commit.ok, true);
-        assert.strictEqual(commit.previousState, "planned");
-        const after = await ledger.getOrCreateIntentCommitRecord({
-            decisionId: "dec-1",
-            intentId: "intent-1",
-            idempotencyKey: "idem-3",
-            effectClass: "side_effect",
-        });
-        assert.strictEqual(after.existing, true);
-        assert.strictEqual(after.record.state, "committed");
-        assert.strictEqual(after.record.outcomeRef, "outcome://ref-1");
-        db.close();
-    });
-    it("markCommitted returns ok:false for unknown key", async () => {
-        const db = createStateDatabase(":memory:");
-        const ledger = createEffectCommitLedgerSQLite(db);
-        const commit = await ledger.markCommitted("unknown", "outcome://ref");
-        assert.strictEqual(commit.ok, false);
-        db.close();
-    });
-    it("survives new ledger instance (process restart simulation)", async () => {
-        const db = createStateDatabase(":memory:");
-        const ledger = createEffectCommitLedgerSQLite(db);
-        await ledger.getOrCreateIntentCommitRecord({
-            decisionId: "dec-1",
-            intentId: "intent-1",
-            idempotencyKey: "idem-restart",
-            effectClass: "side_effect",
-        });
-        await ledger.markCommitted("idem-restart", "outcome://survived");
-        // Simulate process restart by creating a new ledger instance on the same DB
-        const newLedger = createEffectCommitLedgerSQLite(db);
-        const afterRestart = await newLedger.getOrCreateIntentCommitRecord({
-            decisionId: "dec-1",
-            intentId: "intent-1",
-            idempotencyKey: "idem-restart",
-            effectClass: "side_effect",
-        });
-        assert.strictEqual(afterRestart.existing, true);
-        assert.strictEqual(afterRestart.record.state, "committed");
-        assert.strictEqual(afterRestart.record.outcomeRef, "outcome://survived");
-        db.close();
-    });
-});

package/dist/tests/unit/connectors/evomap-runner.test.d.ts

@@ -1 +0,0 @@
-export {};