@haaaiawd/second-nature 0.1.16 → 0.1.18

package/runtime/observability/query/export-audit-bundle.js

@@ -1,27 +1,27 @@
-/**
- * Redacted audit export bundle for operator / retention tooling (T5.3.1).
- *
- * Core logic: load range, attach export metadata; payloads are already redacted at envelope build time.
- *
- * Dependencies: same range loader pattern as verifyAuditHashChain.
- *
- * Test coverage: tests/integration/observability/explain-query-export.test.ts
- */
-import * as crypto from "node:crypto";
-function summarize(events) {
-    const ids = new Set();
-    for (const e of events) {
-        ids.add(e.redaction.manifestId);
-    }
-    return { eventCount: events.length, manifestIds: [...ids] };
-}
-export async function exportAuditBundle(range, deps) {
-    const events = [...(await deps.loadRange(range.from, range.to, range.families))].sort((a, b) => a.sequence - b.sequence);
-    return {
-        bundleId: crypto.randomUUID(),
-        generatedAt: new Date().toISOString(),
-        range,
-        events,
-        redactionSummary: summarize(events),
-    };
-}
+/**
+ * Redacted audit export bundle for operator / retention tooling (T5.3.1).
+ *
+ * Core logic: load range, attach export metadata; payloads are already redacted at envelope build time.
+ *
+ * Dependencies: same range loader pattern as verifyAuditHashChain.
+ *
+ * Test coverage: tests/integration/observability/explain-query-export.test.ts
+ */
+import * as crypto from "node:crypto";
+function summarize(events) {
+    const ids = new Set();
+    for (const e of events) {
+        ids.add(e.redaction.manifestId);
+    }
+    return { eventCount: events.length, manifestIds: [...ids] };
+}
+export async function exportAuditBundle(range, deps) {
+    const events = [...(await deps.loadRange(range.from, range.to, range.families))].sort((a, b) => a.sequence - b.sequence);
+    return {
+        bundleId: crypto.randomUUID(),
+        generatedAt: new Date().toISOString(),
+        range,
+        events,
+        redactionSummary: summarize(events),
+    };
+}

package/runtime/observability/services/decision-ledger.d.ts

@@ -1,46 +1,46 @@
-import type { ObservabilityDatabase } from "../db/index.js";
-import type { DecisionRecord } from "../../shared/types/continuity.js";
-export interface QuietLifecycleEvent {
-    id: string;
-    tickId: string;
-    eventType: "quiet.entered" | "quiet.skipped" | "quiet.interrupted" | "quiet.resumed" | "quiet.suppressed";
-    reason?: string;
-    suppressedBy?: string;
-    reflectionCandidates?: string[];
-    createdAt: string;
-}
-export interface OutreachDecision {
-    id: string;
-    tickId: string;
-    eventType: "outreach.considered" | "outreach.denied" | "outreach.deferred" | "outreach.sent";
-    platformId?: string;
-    targetUserId?: string;
-    valueScore?: number;
-    suppressionReason?: string;
-    messagePreview?: string;
-    createdAt: string;
-}
-export interface HeartbeatDecisionEvent {
-    id: string;
-    tickId: string;
-    traceId: string;
-    runtimeScope: "rhythm" | "user_task" | "user_reply";
-    triggerSource: "heartbeat_bridge" | "user_task" | "user_reply" | "interrupt" | "resume";
-    decisionStatus: "heartbeat_ok" | "intent_selected" | "denied" | "deferred" | "runtime_carrier_only" | "delivery_unavailable";
-    reasons: string[];
-    intentId?: string;
-    mode: "active" | "quiet" | "maintenance_only" | "paused_for_interrupt";
-    createdAt: string;
-}
-export declare class DecisionLedger {
-    private db;
-    constructor(db: ObservabilityDatabase);
-    recordDecision(record: DecisionRecord): Promise<void>;
-    recordHeartbeatDecision(event: HeartbeatDecisionEvent): Promise<void>;
-    recordQuietLifecycle(event: QuietLifecycleEvent): Promise<void>;
-    recordOutreachDecision(event: OutreachDecision): Promise<void>;
-    queryByTickId(tickId: string): Promise<DecisionRecord[]>;
-    queryByTraceId(traceId: string): Promise<DecisionRecord | null>;
-    queryByIntentId(intentId: string): Promise<DecisionRecord[]>;
-    private mapToDecisionRecord;
-}
+import type { ObservabilityDatabase } from "../db/index.js";
+import type { DecisionRecord } from "../../shared/types/continuity.js";
+export interface QuietLifecycleEvent {
+    id: string;
+    tickId: string;
+    eventType: "quiet.entered" | "quiet.skipped" | "quiet.interrupted" | "quiet.resumed" | "quiet.suppressed";
+    reason?: string;
+    suppressedBy?: string;
+    reflectionCandidates?: string[];
+    createdAt: string;
+}
+export interface OutreachDecision {
+    id: string;
+    tickId: string;
+    eventType: "outreach.considered" | "outreach.denied" | "outreach.deferred" | "outreach.sent";
+    platformId?: string;
+    targetUserId?: string;
+    valueScore?: number;
+    suppressionReason?: string;
+    messagePreview?: string;
+    createdAt: string;
+}
+export interface HeartbeatDecisionEvent {
+    id: string;
+    tickId: string;
+    traceId: string;
+    runtimeScope: "rhythm" | "user_task" | "user_reply";
+    triggerSource: "heartbeat_bridge" | "user_task" | "user_reply" | "interrupt" | "resume";
+    decisionStatus: "heartbeat_ok" | "intent_selected" | "denied" | "deferred" | "runtime_carrier_only" | "delivery_unavailable";
+    reasons: string[];
+    intentId?: string;
+    mode: "active" | "quiet" | "maintenance_only" | "paused_for_interrupt";
+    createdAt: string;
+}
+export declare class DecisionLedger {
+    private db;
+    constructor(db: ObservabilityDatabase);
+    recordDecision(record: DecisionRecord): Promise<void>;
+    recordHeartbeatDecision(event: HeartbeatDecisionEvent): Promise<void>;
+    recordQuietLifecycle(event: QuietLifecycleEvent): Promise<void>;
+    recordOutreachDecision(event: OutreachDecision): Promise<void>;
+    queryByTickId(tickId: string): Promise<DecisionRecord[]>;
+    queryByTraceId(traceId: string): Promise<DecisionRecord | null>;
+    queryByIntentId(intentId: string): Promise<DecisionRecord[]>;
+    private mapToDecisionRecord;
+}

package/runtime/observability/services/decision-ledger.js

@@ -1,161 +1,161 @@
-import { eq } from "drizzle-orm";
-import { decisionLedger } from "../db/schema/index.js";
-import { redactEvent } from "../redaction/manifest.js";
-import { persistRedactionManifest } from "./redaction-store.js";
-export class DecisionLedger {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async recordDecision(record) {
-        const { redacted, manifest } = redactEvent(record);
-        await this.db.db.insert(decisionLedger).values({
-            id: redacted.id,
-            tickId: redacted.tickId,
-            traceId: redacted.traceId,
-            intentId: redacted.intentId ?? null,
-            platformId: redacted.platformId ?? null,
-            verdict: redacted.verdict,
-            mode: redacted.mode,
-            reasons: JSON.stringify(redacted.reasons),
-            reasonCodes: JSON.stringify(redacted.reasonCodes),
-            decisionBasis: redacted.decisionBasis,
-            evidenceRefs: JSON.stringify(redacted.evidenceRefs),
-            modelEvalRef: redacted.modelEvalRef ?? null,
-            createdAt: redacted.createdAt,
-        });
-        await persistRedactionManifest(this.db, redacted.id, "decision.recorded", manifest);
-    }
-    async recordHeartbeatDecision(event) {
-        const { redacted, manifest } = redactEvent(event);
-        // Map decisionStatus to existing verdict field without changing business semantics
-        const verdict = mapHeartbeatStatusToVerdict(redacted.decisionStatus);
-        await this.db.db.insert(decisionLedger).values({
-            id: redacted.id,
-            tickId: redacted.tickId,
-            traceId: redacted.traceId,
-            intentId: redacted.intentId ?? null,
-            platformId: null,
-            verdict,
-            mode: redacted.mode,
-            reasons: JSON.stringify(redacted.reasons),
-            reasonCodes: JSON.stringify(["heartbeat_decision"]),
-            decisionBasis: "rule_only",
-            evidenceRefs: JSON.stringify([
-                `scope:${redacted.runtimeScope}`,
-                `trigger:${redacted.triggerSource}`,
-                `status:${redacted.decisionStatus}`,
-            ].filter(Boolean)),
-            modelEvalRef: null,
-            createdAt: redacted.createdAt,
-        });
-        await persistRedactionManifest(this.db, redacted.id, "heartbeat.decision", manifest);
-    }
-    async recordQuietLifecycle(event) {
-        const { redacted, manifest } = redactEvent(event);
-        await this.db.db.insert(decisionLedger).values({
-            id: redacted.id,
-            tickId: redacted.tickId,
-            traceId: `quiet-${redacted.eventType}-${redacted.id}`,
-            intentId: null,
-            platformId: null,
-            verdict: "allow",
-            mode: "quiet",
-            reasons: JSON.stringify([redacted.eventType, redacted.reason ?? ""].filter(Boolean)),
-            reasonCodes: JSON.stringify(["quiet_lifecycle"]),
-            decisionBasis: "rule_only",
-            evidenceRefs: JSON.stringify(redacted.reflectionCandidates ?? []),
-            modelEvalRef: null,
-            createdAt: redacted.createdAt,
-        });
-        await persistRedactionManifest(this.db, redacted.id, redacted.eventType, manifest);
-    }
-    async recordOutreachDecision(event) {
-        const { redacted, manifest } = redactEvent(event);
-        const verdict = redacted.eventType === "outreach.sent"
-            ? "allow"
-            : redacted.eventType === "outreach.deferred" || redacted.eventType === "outreach.considered"
-                ? "defer"
-                : "deny";
-        await this.db.db.insert(decisionLedger).values({
-            id: redacted.id,
-            tickId: redacted.tickId,
-            traceId: `outreach-${redacted.eventType}-${redacted.id}`,
-            intentId: null,
-            platformId: redacted.platformId ?? null,
-            verdict,
-            mode: "active",
-            reasons: JSON.stringify([
-                redacted.eventType,
-                redacted.valueScore?.toString() ?? "",
-                redacted.suppressionReason ?? "",
-            ].filter(Boolean)),
-            reasonCodes: JSON.stringify(["outreach_decision"]),
-            decisionBasis: "score_based",
-            evidenceRefs: JSON.stringify([redacted.targetUserId ?? ""].filter(Boolean)),
-            modelEvalRef: null,
-            createdAt: redacted.createdAt,
-        });
-        await persistRedactionManifest(this.db, redacted.id, redacted.eventType, manifest);
-    }
-    async queryByTickId(tickId) {
-        const results = await this.db.db
-            .select()
-            .from(decisionLedger)
-            .where(eq(decisionLedger.tickId, tickId));
-        return results.map(this.mapToDecisionRecord);
-    }
-    async queryByTraceId(traceId) {
-        const results = await this.db.db
-            .select()
-            .from(decisionLedger)
-            .where(eq(decisionLedger.traceId, traceId))
-            .limit(1);
-        return results[0] ? this.mapToDecisionRecord(results[0]) : null;
-    }
-    async queryByIntentId(intentId) {
-        const results = await this.db.db
-            .select()
-            .from(decisionLedger)
-            .where(eq(decisionLedger.intentId, intentId));
-        return results.map(this.mapToDecisionRecord);
-    }
-    mapToDecisionRecord(row) {
-        return {
-            id: row.id,
-            tickId: row.tickId,
-            traceId: row.traceId,
-            intentId: row.intentId ?? undefined,
-            platformId: row.platformId ?? undefined,
-            verdict: row.verdict,
-            mode: row.mode,
-            reasons: JSON.parse(row.reasons),
-            reasonCodes: JSON.parse(row.reasonCodes),
-            decisionBasis: row.decisionBasis,
-            evidenceRefs: JSON.parse(row.evidenceRefs),
-            modelEvalRef: row.modelEvalRef ?? undefined,
-            createdAt: row.createdAt,
-        };
-    }
-}
-/**
- * Map heartbeat decision status to existing verdict field.
- * This preserves the existing DecisionRecord semantics while allowing
- * heartbeat-specific status to be recoverable from evidenceRefs.
- */
-function mapHeartbeatStatusToVerdict(status) {
-    switch (status) {
-        case "intent_selected":
-            return "allow";
-        case "denied":
-            return "deny";
-        case "deferred":
-            return "defer";
-        case "heartbeat_ok":
-            return "defer";
-        case "runtime_carrier_only":
-            return "defer";
-        case "delivery_unavailable":
-            return "deny";
-    }
-}
+import { eq } from "drizzle-orm";
+import { decisionLedger } from "../db/schema/index.js";
+import { redactEvent } from "../redaction/manifest.js";
+import { persistRedactionManifest } from "./redaction-store.js";
+export class DecisionLedger {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async recordDecision(record) {
+        const { redacted, manifest } = redactEvent(record);
+        await this.db.db.insert(decisionLedger).values({
+            id: redacted.id,
+            tickId: redacted.tickId,
+            traceId: redacted.traceId,
+            intentId: redacted.intentId ?? null,
+            platformId: redacted.platformId ?? null,
+            verdict: redacted.verdict,
+            mode: redacted.mode,
+            reasons: JSON.stringify(redacted.reasons),
+            reasonCodes: JSON.stringify(redacted.reasonCodes),
+            decisionBasis: redacted.decisionBasis,
+            evidenceRefs: JSON.stringify(redacted.evidenceRefs),
+            modelEvalRef: redacted.modelEvalRef ?? null,
+            createdAt: redacted.createdAt,
+        });
+        await persistRedactionManifest(this.db, redacted.id, "decision.recorded", manifest);
+    }
+    async recordHeartbeatDecision(event) {
+        const { redacted, manifest } = redactEvent(event);
+        // Map decisionStatus to existing verdict field without changing business semantics
+        const verdict = mapHeartbeatStatusToVerdict(redacted.decisionStatus);
+        await this.db.db.insert(decisionLedger).values({
+            id: redacted.id,
+            tickId: redacted.tickId,
+            traceId: redacted.traceId,
+            intentId: redacted.intentId ?? null,
+            platformId: null,
+            verdict,
+            mode: redacted.mode,
+            reasons: JSON.stringify(redacted.reasons),
+            reasonCodes: JSON.stringify(["heartbeat_decision"]),
+            decisionBasis: "rule_only",
+            evidenceRefs: JSON.stringify([
+                `scope:${redacted.runtimeScope}`,
+                `trigger:${redacted.triggerSource}`,
+                `status:${redacted.decisionStatus}`,
+            ].filter(Boolean)),
+            modelEvalRef: null,
+            createdAt: redacted.createdAt,
+        });
+        await persistRedactionManifest(this.db, redacted.id, "heartbeat.decision", manifest);
+    }
+    async recordQuietLifecycle(event) {
+        const { redacted, manifest } = redactEvent(event);
+        await this.db.db.insert(decisionLedger).values({
+            id: redacted.id,
+            tickId: redacted.tickId,
+            traceId: `quiet-${redacted.eventType}-${redacted.id}`,
+            intentId: null,
+            platformId: null,
+            verdict: "allow",
+            mode: "quiet",
+            reasons: JSON.stringify([redacted.eventType, redacted.reason ?? ""].filter(Boolean)),
+            reasonCodes: JSON.stringify(["quiet_lifecycle"]),
+            decisionBasis: "rule_only",
+            evidenceRefs: JSON.stringify(redacted.reflectionCandidates ?? []),
+            modelEvalRef: null,
+            createdAt: redacted.createdAt,
+        });
+        await persistRedactionManifest(this.db, redacted.id, redacted.eventType, manifest);
+    }
+    async recordOutreachDecision(event) {
+        const { redacted, manifest } = redactEvent(event);
+        const verdict = redacted.eventType === "outreach.sent"
+            ? "allow"
+            : redacted.eventType === "outreach.deferred" || redacted.eventType === "outreach.considered"
+                ? "defer"
+                : "deny";
+        await this.db.db.insert(decisionLedger).values({
+            id: redacted.id,
+            tickId: redacted.tickId,
+            traceId: `outreach-${redacted.eventType}-${redacted.id}`,
+            intentId: null,
+            platformId: redacted.platformId ?? null,
+            verdict,
+            mode: "active",
+            reasons: JSON.stringify([
+                redacted.eventType,
+                redacted.valueScore?.toString() ?? "",
+                redacted.suppressionReason ?? "",
+            ].filter(Boolean)),
+            reasonCodes: JSON.stringify(["outreach_decision"]),
+            decisionBasis: "score_based",
+            evidenceRefs: JSON.stringify([redacted.targetUserId ?? ""].filter(Boolean)),
+            modelEvalRef: null,
+            createdAt: redacted.createdAt,
+        });
+        await persistRedactionManifest(this.db, redacted.id, redacted.eventType, manifest);
+    }
+    async queryByTickId(tickId) {
+        const results = await this.db.db
+            .select()
+            .from(decisionLedger)
+            .where(eq(decisionLedger.tickId, tickId));
+        return results.map(this.mapToDecisionRecord);
+    }
+    async queryByTraceId(traceId) {
+        const results = await this.db.db
+            .select()
+            .from(decisionLedger)
+            .where(eq(decisionLedger.traceId, traceId))
+            .limit(1);
+        return results[0] ? this.mapToDecisionRecord(results[0]) : null;
+    }
+    async queryByIntentId(intentId) {
+        const results = await this.db.db
+            .select()
+            .from(decisionLedger)
+            .where(eq(decisionLedger.intentId, intentId));
+        return results.map(this.mapToDecisionRecord);
+    }
+    mapToDecisionRecord(row) {
+        return {
+            id: row.id,
+            tickId: row.tickId,
+            traceId: row.traceId,
+            intentId: row.intentId ?? undefined,
+            platformId: row.platformId ?? undefined,
+            verdict: row.verdict,
+            mode: row.mode,
+            reasons: JSON.parse(row.reasons),
+            reasonCodes: JSON.parse(row.reasonCodes),
+            decisionBasis: row.decisionBasis,
+            evidenceRefs: JSON.parse(row.evidenceRefs),
+            modelEvalRef: row.modelEvalRef ?? undefined,
+            createdAt: row.createdAt,
+        };
+    }
+}
+/**
+ * Map heartbeat decision status to existing verdict field.
+ * This preserves the existing DecisionRecord semantics while allowing
+ * heartbeat-specific status to be recoverable from evidenceRefs.
+ */
+function mapHeartbeatStatusToVerdict(status) {
+    switch (status) {
+        case "intent_selected":
+            return "allow";
+        case "denied":
+            return "deny";
+        case "deferred":
+            return "defer";
+        case "heartbeat_ok":
+            return "defer";
+        case "runtime_carrier_only":
+            return "defer";
+        case "delivery_unavailable":
+            return "deny";
+    }
+}

package/runtime/observability/services/governance-audit.d.ts

@@ -1,41 +1,41 @@
-import type { ObservabilityDatabase } from "../db/index.js";
-import type { AnchorChangeAudit } from "../../shared/types/continuity.js";
-export interface CredentialLifecycleAudit {
-    id: string;
-    platformId: string;
-    credentialId: string;
-    statusFrom?: string;
-    statusTo: string;
-    verificationDeadline?: string;
-    attemptsRemaining?: number;
-    explanationCapsule: string;
-    createdAt: string;
-}
-export declare class GovernanceAudit {
-    private db;
-    constructor(db: ObservabilityDatabase);
-    recordAnchorChangeAudit(event: AnchorChangeAudit): Promise<void>;
-    /**
-     * Generic governance-plane events (T5.1.2): fallback_written, effect_commit_advanced, connector_failure, etc.
-     * traceId is stored on target_asset_id for explain/trace correlation until a dedicated column exists.
-     */
-    recordOperationalGovernanceEvent(input: {
-        id: string;
-        eventType: string;
-        traceId: string;
-        statusTo: string;
-        reason: string;
-        assetPath?: string;
-        supportingSources?: string[];
-        createdAt?: string;
-    }): Promise<void>;
-    recordCredentialLifecycle(event: CredentialLifecycleAudit): Promise<void>;
-    recordProposalApply(proposalId: string, targetAssetId: string, assetPath: string, beforeHash: string | undefined, afterHash: string | undefined, supportingSources: string[], reason: string): Promise<void>;
-    recordProposalReject(proposalId: string, targetAssetId: string, assetPath: string, reason: string): Promise<void>;
-    queryByProposalId(proposalId: string): Promise<AnchorChangeAudit[]>;
-    queryByAssetId(assetId: string): Promise<AnchorChangeAudit[]>;
-    queryByEventType(eventType: string): Promise<AnchorChangeAudit[]>;
-    queryCredentialByPlatform(platformId: string): Promise<CredentialLifecycleAudit[]>;
-    private mapToAnchorAudit;
-    private mapToCredentialAudit;
-}
+import type { ObservabilityDatabase } from "../db/index.js";
+import type { AnchorChangeAudit } from "../../shared/types/continuity.js";
+export interface CredentialLifecycleAudit {
+    id: string;
+    platformId: string;
+    credentialId: string;
+    statusFrom?: string;
+    statusTo: string;
+    verificationDeadline?: string;
+    attemptsRemaining?: number;
+    explanationCapsule: string;
+    createdAt: string;
+}
+export declare class GovernanceAudit {
+    private db;
+    constructor(db: ObservabilityDatabase);
+    recordAnchorChangeAudit(event: AnchorChangeAudit): Promise<void>;
+    /**
+     * Generic governance-plane events (T5.1.2): fallback_written, effect_commit_advanced, connector_failure, etc.
+     * traceId is stored on target_asset_id for explain/trace correlation until a dedicated column exists.
+     */
+    recordOperationalGovernanceEvent(input: {
+        id: string;
+        eventType: string;
+        traceId: string;
+        statusTo: string;
+        reason: string;
+        assetPath?: string;
+        supportingSources?: string[];
+        createdAt?: string;
+    }): Promise<void>;
+    recordCredentialLifecycle(event: CredentialLifecycleAudit): Promise<void>;
+    recordProposalApply(proposalId: string, targetAssetId: string, assetPath: string, beforeHash: string | undefined, afterHash: string | undefined, supportingSources: string[], reason: string): Promise<void>;
+    recordProposalReject(proposalId: string, targetAssetId: string, assetPath: string, reason: string): Promise<void>;
+    queryByProposalId(proposalId: string): Promise<AnchorChangeAudit[]>;
+    queryByAssetId(assetId: string): Promise<AnchorChangeAudit[]>;
+    queryByEventType(eventType: string): Promise<AnchorChangeAudit[]>;
+    queryCredentialByPlatform(platformId: string): Promise<CredentialLifecycleAudit[]>;
+    private mapToAnchorAudit;
+    private mapToCredentialAudit;
+}