@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/observability/heartbeat-narrative-trace.test.js

@@ -0,0 +1,230 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { ingestRhythmSignal, } from "../../../src/core/second-nature/heartbeat/index.js";
+test("T5.1.2 narrative trace emitted after successful narrative state update", async () => {
+    const recorded = [];
+    const signal = {
+        trigger: "heartbeat_bridge",
+        scopeHint: "rhythm",
+        payload: { timestamp: "2026-05-16T10:00:00Z" },
+    };
+    const deps = {
+        loadSnapshotInputs: async () => ({
+            mode: "active",
+            currentWindowId: "window-default",
+            pendingObligations: ["check-email"],
+            recentOutreachHashes: [],
+            deniedIntents: [],
+            budgets: { socialUsed: 0, socialLimit: 5 },
+            awaitingUserInput: false,
+            acceptedGoals: [
+                {
+                    goalId: "goal-check-email",
+                    kind: "short_term",
+                    status: "accepted",
+                    origin: "owner_set",
+                    description: "check-email inbox processing",
+                    completionCriteria: "inbox zero",
+                    risk: "low",
+                    priorityHint: 1,
+                    sourceRefs: [],
+                    createdAt: "2026-05-16T00:00:00.000Z",
+                    updatedAt: "2026-05-16T00:00:00.000Z",
+                },
+            ],
+        }),
+        narrativeStateStore: {
+            loadNarrativeState: async () => ({
+                narrativeId: "narrative-001",
+                revision: 3,
+                focus: "prior focus",
+                progress: ["p1"],
+                nextIntent: "i1",
+                confidence: 0.5,
+                sourceRefs: [{ sourceId: "s1", kind: "workspace_artifact", url: "https://a.b" }],
+                unsupportedClaims: [],
+                status: "active",
+                updatedAt: "2026-05-16T09:00:00Z",
+            }),
+            updateNarrativeState: async () => ({
+                narrativeId: "narrative-001",
+                status: "acknowledged",
+            }),
+        },
+        recordNarrativeTrace: async (payload) => {
+            recorded.push(payload);
+        },
+    };
+    const result = await ingestRhythmSignal(signal, deps);
+    assert.equal(result.status, "intent_selected");
+    assert.equal(recorded.length, 1);
+    const trace = recorded[0];
+    assert.ok(trace.traceId.startsWith("narrative_trace:"));
+    assert.equal(trace.narrativeId, "narrative-001");
+    assert.equal(typeof trace.revision, "number");
+    assert.equal(trace.updateSource, "heartbeat");
+    assert.ok(Array.isArray(trace.sourceRefs));
+    assert.ok(Array.isArray(trace.unsupportedClaims));
+    assert.ok(["pass", "degraded", "blocked"].includes(trace.groundingStatus));
+    // T5.1.2: goalInfluenceRefs must propagate the actual accepted goal ids that
+    // influenced the selected intent (not just sourceRefs ids).
+    assert.deepEqual(trace.goalInfluenceRefs, ["goal-check-email"]);
+    assert.ok(typeof trace.createdAt === "string");
+});
+test("T5.1.2 no trace emitted when narrativeStateStore absent", async () => {
+    const recorded = [];
+    const signal = {
+        trigger: "heartbeat_bridge",
+        scopeHint: "rhythm",
+        payload: { timestamp: "2026-05-16T10:00:00Z" },
+    };
+    const deps = {
+        loadSnapshotInputs: async () => ({
+            mode: "active",
+            currentWindowId: "window-default",
+            pendingObligations: ["check-email"],
+            recentOutreachHashes: [],
+            deniedIntents: [],
+            budgets: { socialUsed: 0, socialLimit: 5 },
+            awaitingUserInput: false,
+        }),
+        recordNarrativeTrace: async (payload) => {
+            recorded.push(payload);
+        },
+    };
+    const result = await ingestRhythmSignal(signal, deps);
+    assert.equal(result.status, "intent_selected");
+    assert.equal(recorded.length, 0);
+});
+test("T5.1.2 no trace emitted when recordNarrativeTrace absent even with store", async () => {
+    const signal = {
+        trigger: "heartbeat_bridge",
+        scopeHint: "rhythm",
+        payload: { timestamp: "2026-05-16T10:00:00Z" },
+    };
+    const deps = {
+        loadSnapshotInputs: async () => ({
+            mode: "active",
+            currentWindowId: "window-default",
+            pendingObligations: ["check-email"],
+            recentOutreachHashes: [],
+            deniedIntents: [],
+            budgets: { socialUsed: 0, socialLimit: 5 },
+            awaitingUserInput: false,
+        }),
+        narrativeStateStore: {
+            loadNarrativeState: async () => ({
+                narrativeId: "narrative-002",
+                revision: 1,
+                focus: "f",
+                progress: [],
+                nextIntent: "i",
+                confidence: 0.5,
+                sourceRefs: [],
+                unsupportedClaims: [],
+                status: "active",
+                updatedAt: "2026-05-16T09:00:00Z",
+            }),
+            updateNarrativeState: async () => ({
+                narrativeId: "narrative-002",
+                status: "acknowledged",
+            }),
+        },
+    };
+    const result = await ingestRhythmSignal(signal, deps);
+    assert.equal(result.status, "intent_selected");
+    // should not throw; store updated but no trace emitted
+});
+test("T5.1.2 trace emitter throwing must not block cycle result", async () => {
+    const signal = {
+        trigger: "heartbeat_bridge",
+        scopeHint: "rhythm",
+        payload: { timestamp: "2026-05-16T10:00:00Z" },
+    };
+    const deps = {
+        loadSnapshotInputs: async () => ({
+            mode: "active",
+            currentWindowId: "window-default",
+            pendingObligations: ["check-email"],
+            recentOutreachHashes: [],
+            deniedIntents: [],
+            budgets: { socialUsed: 0, socialLimit: 5 },
+            awaitingUserInput: false,
+        }),
+        narrativeStateStore: {
+            loadNarrativeState: async () => ({
+                narrativeId: "narrative-003",
+                revision: 2,
+                focus: "f",
+                progress: [],
+                nextIntent: "i",
+                confidence: 0.5,
+                sourceRefs: [],
+                unsupportedClaims: [],
+                status: "active",
+                updatedAt: "2026-05-16T09:00:00Z",
+            }),
+            updateNarrativeState: async () => ({
+                narrativeId: "narrative-003",
+                status: "acknowledged",
+            }),
+        },
+        recordNarrativeTrace: async () => {
+            throw new Error("trace_sink_unavailable");
+        },
+    };
+    const result = await ingestRhythmSignal(signal, deps);
+    assert.equal(result.status, "intent_selected");
+    // cycle must complete even when trace emission fails
+});
+test("T5.1.2 groundedStatus=degraded when prior unsupportedClaims preserved", async () => {
+    const recorded = [];
+    const decisionTraces = [];
+    const signal = {
+        trigger: "heartbeat_bridge",
+        scopeHint: "rhythm",
+        payload: { timestamp: "2026-05-16T10:00:00Z" },
+    };
+    // All candidates blocked → no intent selected; prior state preserved including unsupportedClaims
+    const deps = {
+        loadSnapshotInputs: async () => ({
+            mode: "active",
+            currentWindowId: "window-default",
+            pendingObligations: [],
+            recentOutreachHashes: [],
+            deniedIntents: [],
+            budgets: { socialUsed: 0, socialLimit: 5 },
+            awaitingUserInput: true,
+        }),
+        narrativeStateStore: {
+            loadNarrativeState: async () => ({
+                narrativeId: "narrative-004",
+                revision: 1,
+                focus: "f",
+                progress: [],
+                nextIntent: "i",
+                confidence: 0.5,
+                sourceRefs: [],
+                unsupportedClaims: ["claim A", "claim B"],
+                status: "active",
+                updatedAt: "2026-05-16T09:00:00Z",
+            }),
+            updateNarrativeState: async () => ({
+                narrativeId: "narrative-004",
+                status: "acknowledged",
+            }),
+        },
+        recordDecisionTrace: async (payload) => {
+            decisionTraces.push(payload);
+        },
+        recordNarrativeTrace: async (payload) => {
+            recorded.push(payload);
+        },
+    };
+    const result = await ingestRhythmSignal(signal, deps);
+    // Debug: understand the actual flow
+    assert.equal(result.status, "denied");
+    assert.equal(recorded.length, 1);
+    assert.equal(recorded[0].groundingStatus, "degraded");
+    assert.deepEqual(recorded[0].unsupportedClaims, ["claim A", "claim B"]);
+});

package/dist/tests/integration/observability/lived-experience-audit-chain.test.d.ts

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

package/dist/tests/integration/observability/lived-experience-audit-chain.test.js

@@ -0,0 +1,43 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createLivedExperienceAuditRecorder } from "../../../src/observability/services/lived-experience-audit.js";
+const now = () => new Date().toISOString();
+test("T5.2.1 integration: decision + delivery + coverage linked to same decisionId", () => {
+    const rec = createLivedExperienceAuditRecorder();
+    const decisionId = "dec-int-1";
+    const traceId = "trace-int-1";
+    rec.recordDecisionTrace({
+        decisionId,
+        traceId,
+        runtimeScope: "rhythm",
+        outcome: "delivery_unavailable",
+        reasonCodes: ["target_none"],
+        sourceRefs: [],
+        createdAt: now(),
+    });
+    rec.recordDeliveryAudit({
+        auditId: "da-int-1",
+        decisionId,
+        traceId,
+        status: "target_none",
+        reasonCodes: ["not_delivered_by_host_policy"],
+        createdAt: now(),
+    });
+    rec.recordSourceCoverage({
+        auditId: "sc-int-1",
+        traceId,
+        decisionId,
+        subjectType: "outreach_draft",
+        subjectRef: "subj-1",
+        usedSourceRefs: [],
+        unresolvedRefs: [],
+        coverageRatio: 0,
+        unsupportedClaims: [],
+        status: "blocked",
+        reasonCodes: ["empty_evidence"],
+        createdAt: now(),
+    });
+    const ex = rec.explainLinkageForDecision(decisionId);
+    assert.ok(ex.relatedEventIds.length >= 3);
+    assert.ok(ex.warnings.includes("no_user_visible_contact_claim_prohibited"));
+});

package/dist/tests/integration/observability/observability-gates.test.d.ts

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

package/dist/tests/integration/observability/observability-gates.test.js

@@ -0,0 +1,224 @@
+import { afterEach, test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { DecisionLedger } from "../../../src/observability/services/decision-ledger.js";
+import { GovernanceAudit } from "../../../src/observability/services/governance-audit.js";
+import { ExecutionTelemetry } from "../../../src/observability/services/execution-telemetry.js";
+import { EvidenceQueryEngine } from "../../../src/observability/query/evidence-query-engine.js";
+import { decisionLedger as decisionLedgerTable, governanceAudit as governanceAuditTable, redactionManifest as redactionManifestTable, executionAttempts as executionAttemptsTable, } from "../../../src/observability/db/schema/index.js";
+const cleanupPaths = [];
+afterEach(() => {
+    while (cleanupPaths.length > 0) {
+        const target = cleanupPaths.pop();
+        if (target && fs.existsSync(target)) {
+            fs.rmSync(target, { force: true });
+        }
+    }
+});
+function createTempDb() {
+    const dbPath = path.join(os.tmpdir(), `observability-gates-${Date.now()}-${Math.random().toString(16).slice(2)}.db`);
+    cleanupPaths.push(dbPath);
+    const database = createObservabilityDatabase(dbPath);
+    database.sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS decision_ledger (
+      id TEXT PRIMARY KEY,
+      tick_id TEXT NOT NULL,
+      trace_id TEXT NOT NULL,
+      intent_id TEXT,
+      platform_id TEXT,
+      verdict TEXT NOT NULL,
+      mode TEXT NOT NULL,
+      reasons TEXT NOT NULL,
+      reason_codes TEXT NOT NULL,
+      decision_basis TEXT NOT NULL,
+      evidence_refs TEXT NOT NULL,
+      model_eval_ref TEXT,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS execution_attempts (
+      id TEXT PRIMARY KEY,
+      trace_id TEXT NOT NULL,
+      decision_id TEXT NOT NULL,
+      intent_id TEXT NOT NULL,
+      platform_id TEXT NOT NULL,
+      capability TEXT NOT NULL,
+      channel TEXT NOT NULL,
+      status TEXT NOT NULL,
+      commit_state TEXT,
+      failure_class TEXT,
+      retry_policy TEXT,
+      idempotency_key TEXT,
+      started_at TEXT,
+      finished_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS governance_audit (
+      id TEXT PRIMARY KEY,
+      event_type TEXT NOT NULL,
+      proposal_id TEXT,
+      target_asset_id TEXT,
+      asset_path TEXT,
+      status_from TEXT,
+      status_to TEXT NOT NULL,
+      before_hash TEXT,
+      after_hash TEXT,
+      supporting_sources TEXT,
+      reason TEXT,
+      verification_deadline TEXT,
+      attempts_remaining INTEGER,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS redaction_manifest (
+      id TEXT PRIMARY KEY,
+      event_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      field_name TEXT NOT NULL,
+      action TEXT NOT NULL,
+      original_value_hash TEXT,
+      created_at TEXT NOT NULL
+    );
+  `);
+    return database;
+}
+test("quality gate: deny path is recorded and queryable", async () => {
+    const db = createTempDb();
+    const ledger = new DecisionLedger(db);
+    const queryEngine = new EvidenceQueryEngine(db);
+    const denyDecision = {
+        id: "decision-deny-1",
+        tickId: "tick-deny-1",
+        traceId: "trace-deny-1",
+        intentId: "intent-deny-1",
+        platformId: "instreet",
+        verdict: "deny",
+        mode: "active",
+        reasons: ["quiet_window"],
+        reasonCodes: ["quiet_window"],
+        decisionBasis: "rule_only",
+        evidenceRefs: ["content_ref:quiet/1"],
+        createdAt: new Date().toISOString(),
+    };
+    await ledger.recordDecision(denyDecision);
+    const rows = await db.db.select().from(decisionLedgerTable);
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0]?.verdict, "deny");
+    const bundle = await queryEngine.queryEvidence({ decisionId: "decision-deny-1" });
+    assert.equal(bundle.decisions.length, 1);
+    assert.equal(bundle.decisions[0]?.verdict, "deny");
+    db.close();
+});
+test("quality gate: anchor audit preserves before/after hash diff evidence", async () => {
+    const db = createTempDb();
+    const governance = new GovernanceAudit(db);
+    const anchorEvent = {
+        id: "anchor-audit-1",
+        proposalId: "proposal-audit-1",
+        targetAssetId: "SOUL.md",
+        assetPath: "workspace/SOUL.md",
+        status: "applied",
+        beforeHash: "before-hash",
+        afterHash: "after-hash",
+        supportingSources: ["content_ref:day/10"],
+        reason: "approved update",
+        createdAt: new Date().toISOString(),
+    };
+    await governance.recordAnchorChangeAudit(anchorEvent);
+    const rows = await db.db.select().from(governanceAuditTable);
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0]?.proposalId, "proposal-audit-1");
+    assert.equal(rows[0]?.beforeHash, "before-hash");
+    assert.equal(rows[0]?.afterHash, "after-hash");
+    db.close();
+});
+test("quality gate: credential lifecycle audit is persisted and retrievable by platform", async () => {
+    const db = createTempDb();
+    const governance = new GovernanceAudit(db);
+    await governance.recordCredentialLifecycle({
+        id: "cred-audit-1",
+        platformId: "instreet",
+        credentialId: "cred-instreet-1",
+        statusFrom: "pending_verification",
+        statusTo: "active",
+        verificationDeadline: new Date().toISOString(),
+        attemptsRemaining: 2,
+        explanationCapsule: "verification completed",
+        createdAt: new Date().toISOString(),
+    });
+    const records = await governance.queryCredentialByPlatform("instreet");
+    assert.equal(records.length, 1);
+    assert.equal(records[0]?.statusTo, "active");
+    assert.equal(records[0]?.credentialId, "cred-instreet-1");
+    db.close();
+});
+test("quality gate: evidence query links decision and execution attempt", async () => {
+    const db = createTempDb();
+    const ledger = new DecisionLedger(db);
+    const telemetry = new ExecutionTelemetry(db);
+    const queryEngine = new EvidenceQueryEngine(db);
+    await ledger.recordDecision({
+        id: "decision-link-1",
+        tickId: "tick-link-1",
+        traceId: "trace-link-1",
+        intentId: "intent-link-1",
+        platformId: "evomap",
+        verdict: "allow",
+        mode: "active",
+        reasons: ["policy_ok"],
+        reasonCodes: ["policy_ok"],
+        decisionBasis: "rule_only",
+        evidenceRefs: ["content_ref:link/1"],
+        createdAt: new Date().toISOString(),
+    });
+    const attempt = {
+        id: "attempt-link-1",
+        traceId: "trace-link-1",
+        decisionId: "decision-link-1",
+        intentId: "intent-link-1",
+        platformId: "evomap",
+        capability: "agent.heartbeat",
+        channel: "api_rest",
+        status: "succeeded",
+        commitState: "committed",
+        startedAt: new Date().toISOString(),
+        finishedAt: new Date().toISOString(),
+    };
+    await telemetry.recordExecutionAttempt(attempt);
+    const bundle = await queryEngine.queryEvidence({ decisionId: "decision-link-1" });
+    assert.equal(bundle.decisions.length, 1);
+    assert.equal(bundle.attempts.length, 1);
+    assert.equal(bundle.attempts[0]?.decisionId, "decision-link-1");
+    assert.equal(bundle.governance.length, 0);
+    db.close();
+});
+test("quality gate: redaction security prevents sensitive plaintext from landing", async () => {
+    const db = createTempDb();
+    const telemetry = new ExecutionTelemetry(db);
+    const attempt = {
+        id: "attempt-redact-1",
+        traceId: "trace-redact-1",
+        decisionId: "decision-redact-1",
+        intentId: "intent-redact-1",
+        platformId: "evomap",
+        capability: "agent.register",
+        channel: "api_rest",
+        status: "started",
+        commitState: "planned",
+        metadata: {
+            node_secret: "plaintext-should-not-persist",
+        },
+        startedAt: new Date().toISOString(),
+    };
+    await telemetry.recordExecutionAttempt(attempt);
+    const attemptRows = await db.db.select().from(executionAttemptsTable);
+    assert.equal(attemptRows.length, 1);
+    assert.equal(attemptRows[0]?.id, "attempt-redact-1");
+    const redactionRows = await db.db.select().from(redactionManifestTable);
+    assert.ok(redactionRows.some((row) => row.fieldName === "metadata.node_secret" && row.action === "mask"));
+    assert.ok(!redactionRows.some((row) => row.fieldName.includes("node_secret") && row.action === "none"));
+    db.close();
+});

package/dist/tests/integration/observability/observability-retention-cleanup.test.d.ts

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

package/dist/tests/integration/observability/observability-retention-cleanup.test.js

@@ -0,0 +1,94 @@
+/**
+ * P2-06 — Observability retention cleanup.
+ *
+ * Verifies that `pruneObservabilityTables` deletes rows older than a
+ * threshold while leaving newer rows intact.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { decisionLedger, executionAttempts, } from "../../../src/observability/db/schema/index.js";
+import { pruneObservabilityTables } from "../../../src/observability/services/observability-retention.js";
+async function seedDecisionLedger(db) {
+    await db.db.insert(decisionLedger).values([
+        {
+            id: "dl-old",
+            tickId: "t1",
+            traceId: "tr-old",
+            verdict: "denied",
+            mode: "active",
+            reasons: "[]",
+            reasonCodes: "[]",
+            decisionBasis: "rule_only",
+            evidenceRefs: "[]",
+            createdAt: "2026-05-01T00:00:00.000Z",
+        },
+        {
+            id: "dl-new",
+            tickId: "t2",
+            traceId: "tr-new",
+            verdict: "denied",
+            mode: "active",
+            reasons: "[]",
+            reasonCodes: "[]",
+            decisionBasis: "rule_only",
+            evidenceRefs: "[]",
+            createdAt: "2026-05-11T00:00:00.000Z",
+        },
+    ]);
+}
+async function seedExecutionAttempts(db) {
+    await db.db.insert(executionAttempts).values([
+        {
+            id: "ea-old",
+            traceId: "tr-old",
+            decisionId: "d1",
+            intentId: "i1",
+            platformId: "p1",
+            capability: "cap",
+            channel: "ch",
+            status: "failed",
+            startedAt: "2026-05-01T00:00:00.000Z",
+        },
+        {
+            id: "ea-new",
+            traceId: "tr-new",
+            decisionId: "d2",
+            intentId: "i2",
+            platformId: "p2",
+            capability: "cap",
+            channel: "ch",
+            status: "succeeded",
+            startedAt: "2026-05-11T00:00:00.000Z",
+        },
+    ]);
+}
+test("P2-06: prune deletes old rows and preserves new ones", async () => {
+    const db = createObservabilityDatabase(":memory:");
+    await seedDecisionLedger(db);
+    await seedExecutionAttempts(db);
+    const result = await pruneObservabilityTables(db, {
+        beforeDate: "2026-05-10T00:00:00.000Z",
+    });
+    assert.equal(result.decisionLedgerDeleted, 1, "one old decision ledger row deleted");
+    assert.equal(result.executionAttemptsDeleted, 1, "one old execution attempt row deleted");
+    const remainingDL = await db.db.select().from(decisionLedger);
+    const remainingEA = await db.db.select().from(executionAttempts);
+    assert.equal(remainingDL.length, 1, "one decision ledger row remains");
+    assert.equal(remainingDL[0].id, "dl-new", "remaining row is the new one");
+    assert.equal(remainingEA.length, 1, "one execution attempt row remains");
+    assert.equal(remainingEA[0].id, "ea-new", "remaining row is the new one");
+    db.close();
+});
+test("P2-06: prune with past date deletes nothing", async () => {
+    const db = createObservabilityDatabase(":memory:");
+    await seedDecisionLedger(db);
+    await seedExecutionAttempts(db);
+    // All seeded rows are on 2026-05-01 or 2026-05-11; pruning before 2026-01-01 should match nothing.
+    const result = await pruneObservabilityTables(db, {
+        beforeDate: "2026-01-01T00:00:00.000Z",
+    });
+    assert.equal(result.decisionLedgerDeleted, 0);
+    assert.equal(result.executionAttemptsDeleted, 0);
+    db.close();
+});

package/dist/tests/integration/observability/observability-services.test.d.ts

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