@haaaiawd/second-nature 0.1.50 → 0.1.51

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

@@ -1,230 +0,0 @@
-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

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

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

@@ -1,43 +0,0 @@
-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

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

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

@@ -1,224 +0,0 @@
-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

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

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

@@ -1,94 +0,0 @@
-/**
- * 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

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