@haaaiawd/second-nature 0.1.21 → 0.1.23

package/runtime/core/second-nature/orchestrator/goal-priority.d.ts

@@ -0,0 +1,19 @@
+/**
+ * T2.1.4 — Goal-Directed Intent Priority.
+ *
+ * `applyGoalPriority` adjusts candidate intent priorities based on accepted AgentGoals.
+ * Priority order: user_task > accepted_goal > rhythm.
+ * Only goals with status === "accepted" and origin !== "agent_proposed" are considered.
+ * All other statuses (proposal / rejected / completed / paused) are implicitly excluded.
+ */
+import type { CandidateIntent } from "../types.js";
+import type { AgentGoal } from "../../../storage/goal/agent-goal-store.js";
+export interface ApplyGoalPriorityResult {
+    candidates: CandidateIntent[];
+    goalInfluences: Array<{
+        candidateId: string;
+        goalIds: string[];
+        boost: number;
+    }>;
+}
+export declare function applyGoalPriority(candidates: CandidateIntent[], goals: AgentGoal[] | undefined): ApplyGoalPriorityResult;

package/runtime/core/second-nature/orchestrator/goal-priority.js

@@ -0,0 +1,67 @@
+/**
+ * Per-goal priority boost applied when an accepted goal matches a candidate.
+ *
+ * Rationale: +20 per goal keeps a priority-50 candidate under 200
+ * even with 7 matching goals (50 + 140 = 190). Planner baselines
+ * range from 40–100, so 200 provides ample headroom without overflow.
+ */
+const GOAL_PRIORITY_BOOST = 20;
+function isGoalRelatedToCandidate(goal, candidate) {
+    if (!candidate.platformId)
+        return false;
+    const goalText = `${goal.description} ${goal.completionCriteria}`.toLowerCase();
+    const platformId = candidate.platformId.toLowerCase();
+    // Direct platformId mention in goal text
+    if (goalText.includes(platformId))
+        return true;
+    // Goal description contains candidate summary keywords
+    const summaryWords = candidate.summary.toLowerCase().split(/\s+/);
+    for (const word of summaryWords) {
+        if (word.length > 3 && goalText.includes(word))
+            return true;
+    }
+    return false;
+}
+export function applyGoalPriority(candidates, goals) {
+    const acceptedGoals = (goals ?? []).filter((g) => g.status === "accepted" && g.origin !== "agent_proposed");
+    if (acceptedGoals.length === 0) {
+        return {
+            candidates: candidates.map((c) => ({
+                ...c,
+                priorityReasons: c.priorityReasons ?? ["rhythm"],
+            })),
+            goalInfluences: [],
+        };
+    }
+    const influences = [];
+    const adjusted = candidates.map((candidate) => {
+        const relatedGoals = acceptedGoals.filter((g) => isGoalRelatedToCandidate(g, candidate));
+        if (relatedGoals.length === 0) {
+            return {
+                ...candidate,
+                priorityReasons: candidate.priorityReasons ?? ["rhythm"],
+            };
+        }
+        const boost = GOAL_PRIORITY_BOOST * relatedGoals.length;
+        const goalIds = relatedGoals.map((g) => g.goalId);
+        influences.push({
+            candidateId: candidate.id,
+            goalIds,
+            boost,
+        });
+        const reasons = [
+            ...(candidate.priorityReasons ?? ["rhythm"]),
+            ...relatedGoals.map((g) => `goal_boost:${g.goalId}`),
+        ];
+        return {
+            ...candidate,
+            priority: candidate.priority + boost,
+            goalInfluenceRefs: goalIds,
+            priorityReasons: reasons,
+        };
+    });
+    return {
+        candidates: adjusted.sort((a, b) => b.priority - a.priority),
+        goalInfluences: influences,
+    };
+}

package/runtime/core/second-nature/orchestrator/intent-planner.js

@@ -34,6 +34,7 @@ function planWorkIntents(runtime) {
         effectClass: "connector_action",
         sourceRefs: [...OBLIGATION_SOURCE],
         idempotencyKey: `obligation:${obligation}:${index}`,
+        goalInfluenceRefs: [],
     }));
 }
 function planExplorationIntents(runtime) {
@@ -50,6 +51,7 @@ function planExplorationIntents(runtime) {
             effectClass: "connector_action",
             sourceRefs: refs,
             idempotencyKey: "exploration:scan platform opportunities",
+            goalInfluenceRefs: [],
         },
     ];
 }
@@ -67,6 +69,7 @@ function planSocialIntents(runtime) {
             effectClass: "connector_action",
             sourceRefs: refs,
             idempotencyKey: "social:engage social platforms",
+            goalInfluenceRefs: [],
         },
     ];
 }
@@ -85,6 +88,7 @@ function planQuietReflectionIntents(runtime) {
             effectClass: "no_effect",
             sourceRefs: [],
             idempotencyKey: "quiet:bookkeeping",
+            goalInfluenceRefs: [],
         });
     }
     if (isAllowedKind("maintenance", runtime)) {
@@ -97,6 +101,7 @@ function planQuietReflectionIntents(runtime) {
             effectClass: "maintenance",
             sourceRefs: [],
             idempotencyKey: "maintenance:checks",
+            goalInfluenceRefs: [],
         });
     }
     if (isAllowedKind("reflection", runtime)) {
@@ -110,6 +115,7 @@ function planQuietReflectionIntents(runtime) {
             effectClass: "narrative_reflection",
             sourceRefs: refs,
             idempotencyKey: "reflection:narrative",
+            goalInfluenceRefs: [],
         });
     }
     return out;
@@ -131,6 +137,7 @@ function planOutreachIntents(runtime) {
             effectClass: "user_outreach",
             sourceRefs: refs,
             idempotencyKey: "outreach:consider proactive user outreach",
+            goalInfluenceRefs: [],
         },
     ];
 }
@@ -149,6 +156,7 @@ export function planCandidateIntents(runtime) {
                 effectClass: "maintenance",
                 sourceRefs: [],
                 idempotencyKey: "maintenance:checks",
+                goalInfluenceRefs: [],
             },
         ];
         return pausedMaintenance

package/runtime/core/second-nature/orchestrator/narrative-update.d.ts

@@ -0,0 +1,27 @@
+/**
+ * T2.1.5 — NarrativeState update after heartbeat effect/fallback.
+ *
+ * Produces a source-backed narrative revision or an honest empty-state
+ * (`awaiting_sources` / `insufficient_sources`) based on the cycle result.
+ *
+ * Rules-only implementation; no live LLM.
+ */
+import type { HeartbeatCycleResult } from "../heartbeat/signal.js";
+import type { CandidateIntent } from "../types.js";
+import type { PlannerLifeEvidenceSlice } from "../heartbeat/runtime-snapshot.js";
+import type { NarrativeState, NarrativeStateUpdate } from "../../../storage/narrative/narrative-state-store.js";
+export interface UpdateNarrativeAfterEffectInput {
+    result: HeartbeatCycleResult;
+    selectedIntent?: CandidateIntent;
+    lifeEvidence: PlannerLifeEvidenceSlice;
+    priorNarrative?: NarrativeState | null;
+}
+/**
+ * Build the next NarrativeState revision from a completed heartbeat cycle.
+ *
+ * - `intent_selected` + sources → `active`, focus/progress updated.
+ * - `intent_selected` without sources → `awaiting_sources`, claim recorded as unsupported.
+ * - No action (heartbeat_ok / denied / deferred / etc.) → preserve prior state or
+ *   seed an empty `awaiting_sources` state when no prior exists.
+ */
+export declare function updateNarrativeAfterEffect(input: UpdateNarrativeAfterEffectInput): NarrativeStateUpdate;

package/runtime/core/second-nature/orchestrator/narrative-update.js

@@ -0,0 +1,107 @@
+const MAX_PROGRESS_ENTRIES = 10;
+const DEFAULT_NARRATIVE_ID = "default";
+function mapControlPlaneRefToSourceRef(ref) {
+    return {
+        sourceId: ref.id,
+        kind: ref.kind,
+        url: ref.uri,
+        snippet: ref.excerptHash,
+    };
+}
+/**
+ * Compute narrative confidence based on source evidence.
+ *
+ * Formula: min(intentSources / 3, 1) + (lifeEvidenceSources > 0 ? 0.1 : 0)
+ *
+ * Rationale:
+ * - Base: 1/3 per intent source (3 sources = 100% confidence)
+ * - Boost: +0.1 if any life evidence exists (signals corroboration)
+ * - Capped at 1.0 (100%)
+ */
+function computeConfidence(intentSources, lifeEvidenceSources) {
+    if (intentSources === 0 && lifeEvidenceSources === 0)
+        return 0;
+    const base = Math.min(intentSources / 3, 1);
+    const boost = lifeEvidenceSources > 0 ? 0.1 : 0;
+    return Math.min(base + boost, 1);
+}
+/**
+ * Build the next NarrativeState revision from a completed heartbeat cycle.
+ *
+ * - `intent_selected` + sources → `active`, focus/progress updated.
+ * - `intent_selected` without sources → `awaiting_sources`, claim recorded as unsupported.
+ * - No action (heartbeat_ok / denied / deferred / etc.) → preserve prior state or
+ *   seed an empty `awaiting_sources` state when no prior exists.
+ */
+export function updateNarrativeAfterEffect(input) {
+    const { result, selectedIntent, lifeEvidence, priorNarrative } = input;
+    const now = new Date().toISOString();
+    const prior = priorNarrative ?? null;
+    const narrativeId = prior?.narrativeId ?? DEFAULT_NARRATIVE_ID;
+    const nextRevision = (prior?.revision ?? 0) + 1;
+    // --- intent_selected branch ------------------------------------------------
+    if (result.status === "intent_selected" && selectedIntent) {
+        const hasIntentSources = selectedIntent.sourceRefs.length > 0;
+        const hasLifeEvidence = !(lifeEvidence.evidenceRefs.length === 0 &&
+            lifeEvidence.platformEventCount === 0 &&
+            lifeEvidence.workEventCount === 0);
+        const sourceRefs = selectedIntent.sourceRefs.map(mapControlPlaneRefToSourceRef);
+        if (hasIntentSources || hasLifeEvidence) {
+            // Source-backed revision
+            const progressEntry = `${selectedIntent.effectClass}: ${selectedIntent.summary}`;
+            const progress = [...(prior?.progress ?? [])];
+            if (!progress.includes(progressEntry)) {
+                progress.push(progressEntry);
+            }
+            const boundedProgress = progress.slice(-MAX_PROGRESS_ENTRIES);
+            return {
+                narrativeId,
+                revision: nextRevision,
+                focus: selectedIntent.summary,
+                progress: boundedProgress,
+                nextIntent: "continue",
+                confidence: computeConfidence(selectedIntent.sourceRefs.length, lifeEvidence.evidenceRefs.length),
+                sourceRefs,
+                unsupportedClaims: [],
+                status: "active",
+                updatedAt: now,
+            };
+        }
+        // No sources → awaiting_sources
+        return {
+            narrativeId,
+            revision: nextRevision,
+            focus: prior?.focus ?? "awaiting_evidence",
+            progress: prior?.progress ?? [],
+            nextIntent: "await_sources",
+            confidence: 0,
+            sourceRefs: [],
+            unsupportedClaims: [selectedIntent.summary],
+            status: "awaiting_sources",
+            updatedAt: now,
+        };
+    }
+    // --- No action / fallback branches -----------------------------------------
+    if (prior) {
+        // Preserve existing state, bump revision and timestamp so observers
+        // know the heartbeat cycle ran even when no intent was selected.
+        return {
+            ...prior,
+            revision: nextRevision,
+            updatedAt: now,
+        };
+    }
+    // No prior state and no action → seed empty awaiting_sources state
+    return {
+        narrativeId,
+        revision: nextRevision,
+        focus: "awaiting_evidence",
+        progress: [],
+        nextIntent: "await_sources",
+        confidence: 0,
+        sourceRefs: [],
+        unsupportedClaims: [],
+        status: "awaiting_sources",
+        updatedAt: now,
+    };
+}

package/runtime/core/second-nature/runtime/service-entry.js

@@ -27,7 +27,7 @@ export function startRuntimeService(ctx) {
     // - control-plane-system (heartbeat bridge preparation)
     const workspaceRoot = ctx?.workspaceRoot ?? process.cwd();
     /** Keep in sync with `plugin/package.json` when cutting releases. */
-    const version = "0.1.20";
+    const version = "0.1.21";
     activeHandle = {
         ready: true,
         version,

package/runtime/core/second-nature/types.d.ts

@@ -41,6 +41,10 @@ export interface CandidateIntent {
     sourceRefs: ControlPlaneSourceRef[];
     /** Dedupe / cooldown key; defaults to stable fingerprint in guard layer when omitted. */
     idempotencyKey?: string;
+    /** T2.1.4: IDs of accepted AgentGoals that influenced this candidate's priority. */
+    goalInfluenceRefs?: string[];
+    /** T2.1.4: Human-readable reasons for the priority value (goal influence, user task, rhythm). */
+    priorityReasons?: string[];
 }
 export interface GuardEvaluation {
     verdict: GuardVerdict;

package/runtime/guidance/draft-narrative-outreach.d.ts

@@ -0,0 +1,36 @@
+/**
+ * T6.1.1 — Narrative Outreach Draft generator.
+ *
+ * Produces source-backed outreach drafts from evidence + narrative + relationship.
+ * Rules-only implementation (no live LLM); honors grounding, redaction, and insufficient_history.
+ *
+ * NOTE: This function assumes narrativeState.focus / nextIntent and
+ * relationshipMemory fields are pre-redacted by upstream state-system.
+ * No additional PII filtering is applied here — defense-in-depth is
+ * the responsibility of the NarrativeState / RelationshipMemory stores.
+ */
+import type { NarrativeState, SourceRef } from "../storage/narrative/narrative-state-store.js";
+import type { RelationshipMemory } from "../storage/relationship/relationship-memory-store.js";
+export interface NarrativeOutreachDraftRequest {
+    evidenceRefs: SourceRef[];
+    narrativeState?: NarrativeState;
+    relationshipMemory?: RelationshipMemory;
+    platformId?: string;
+}
+export interface GroundingReport {
+    status: "grounded" | "degraded" | "blocked";
+    sourceCoverage: number;
+    unsupportedClaims: string[];
+    reason: string;
+}
+export interface NarrativeOutreachDraftResult {
+    draft: {
+        whatHappened: string;
+        whyItMatters: string;
+        sourceRefs: SourceRef[];
+        tone: "friend" | "insufficient_history" | "blocked";
+    };
+    groundingReport: GroundingReport;
+    promptVersion: string;
+}
+export declare function draftNarrativeOutreach(request: NarrativeOutreachDraftRequest): NarrativeOutreachDraftResult;

package/runtime/guidance/draft-narrative-outreach.js

@@ -0,0 +1,84 @@
+function computeSourceCoverage(claims, _evidenceRefs, narrativeSourceRefs) {
+    if (claims.length === 0)
+        return { coverage: 1, unsupported: [] };
+    // Only narrative-level source refs count toward coverage.
+    const count = narrativeSourceRefs?.length ?? 0;
+    const coverage = Math.min(count / claims.length, 1);
+    return {
+        coverage,
+        unsupported: coverage >= 1 ? [] : claims,
+    };
+}
+export function draftNarrativeOutreach(request) {
+    const { evidenceRefs, narrativeState, relationshipMemory, platformId } = request;
+    // T6.1.1 — Block when source refs are missing
+    if (!evidenceRefs || evidenceRefs.length === 0) {
+        return {
+            draft: {
+                whatHappened: "",
+                whyItMatters: "",
+                sourceRefs: [],
+                tone: "blocked",
+            },
+            groundingReport: {
+                status: "blocked",
+                sourceCoverage: 0,
+                unsupportedClaims: ["missing_evidence_refs"],
+                reason: "no_source_refs_provided",
+            },
+            promptVersion: "v6-rules-only-1.0",
+        };
+    }
+    // Build claims from narrative state
+    const claims = [];
+    if (narrativeState?.focus) {
+        claims.push(narrativeState.focus);
+    }
+    if (narrativeState?.progress && narrativeState.progress.length > 0) {
+        claims.push(...narrativeState.progress);
+    }
+    const { coverage, unsupported } = computeSourceCoverage(claims, evidenceRefs, narrativeState?.sourceRefs);
+    // T6.1.1 — Degrade when source coverage is low
+    if (coverage < 0.5) {
+        return {
+            draft: {
+                whatHappened: narrativeState?.focus ?? "",
+                whyItMatters: "",
+                sourceRefs: evidenceRefs,
+                tone: "insufficient_history",
+            },
+            groundingReport: {
+                status: "degraded",
+                sourceCoverage: coverage,
+                unsupportedClaims: unsupported,
+                reason: "insufficient_source_coverage",
+            },
+            promptVersion: "v6-rules-only-1.0",
+        };
+    }
+    // T6.1.1 — insufficient_history tone when relationship is weak
+    const avgAffinity = relationshipMemory && relationshipMemory.topicAffinities.length > 0
+        ? relationshipMemory.topicAffinities.reduce((s, t) => s + t.affinity, 0) /
+            relationshipMemory.topicAffinities.length
+        : 0;
+    const tone = avgAffinity < 0.3 ? "insufficient_history" : "friend";
+    const whatHappened = narrativeState?.focus ?? "Recent activity observed.";
+    const whyItMatters = narrativeState?.nextIntent
+        ? `This relates to the current focus: ${narrativeState.nextIntent}.`
+        : "This may be relevant to your interests.";
+    return {
+        draft: {
+            whatHappened,
+            whyItMatters,
+            sourceRefs: evidenceRefs,
+            tone,
+        },
+        groundingReport: {
+            status: "grounded",
+            sourceCoverage: coverage,
+            unsupportedClaims: unsupported,
+            reason: "source_backed",
+        },
+        promptVersion: "v6-rules-only-1.0",
+    };
+}

package/runtime/guidance/index.d.ts

@@ -9,3 +9,4 @@ export * from "./guidance-assembler.js";
 export * from "./outreach-draft-schema.js";
 export * from "./draft-outreach-message.js";
 export * from "./evidence-guidance.js";
+export * from "./draft-narrative-outreach.js";

package/runtime/guidance/index.js

@@ -9,3 +9,4 @@ export * from "./guidance-assembler.js";
 export * from "./outreach-draft-schema.js";
 export * from "./draft-outreach-message.js";
 export * from "./evidence-guidance.js";
+export * from "./draft-narrative-outreach.js";

package/runtime/guidance/outreach-draft-schema.d.ts

@@ -53,10 +53,10 @@ export declare const sceneGuidanceRequestSchema: z.ZodObject<{
     rhythmWindowKind: z.ZodOptional<z.ZodEnum<{
         quiet: "quiet";
         social: "social";
+        maintenance: "maintenance";
         work: "work";
         exploration: "exploration";
         reflection: "reflection";
-        maintenance: "maintenance";
     }>>;
     riskLevel: z.ZodEnum<{
         medium: "medium";
@@ -107,10 +107,10 @@ export declare const outreachDraftRequestSchema: z.ZodObject<{
     rhythmWindowKind: z.ZodOptional<z.ZodEnum<{
         quiet: "quiet";
         social: "social";
+        maintenance: "maintenance";
         work: "work";
         exploration: "exploration";
         reflection: "reflection";
-        maintenance: "maintenance";
     }>>;
     riskLevel: z.ZodEnum<{
         medium: "medium";
@@ -205,7 +205,7 @@ export declare function safeParseOutreachDraftRequest(input: unknown): z.ZodSafe
         excerptHash?: string | undefined;
         observedAt?: string | undefined;
     }[];
-    rhythmWindowKind?: "quiet" | "social" | "work" | "exploration" | "reflection" | "maintenance" | undefined;
+    rhythmWindowKind?: "quiet" | "social" | "maintenance" | "work" | "exploration" | "reflection" | undefined;
     deliveryContext?: {
         deliveryVerdict: "target_none" | "channel_missing" | "host_unsupported" | "delivery_failed" | "target_available";
         wordingMode: "sendable" | "not_sent_fallback_candidate";

package/runtime/observability/connector-inventory-ledger.d.ts

@@ -0,0 +1,45 @@
+import type { ObservabilityDatabase } from "./db/index.js";
+export interface InventorySnapshot {
+    auditId: string;
+    snapshotId: string;
+    scanned: number;
+    registered: number;
+    skipped: number;
+    conflicts: Array<{
+        connectorId: string;
+        reason: string;
+    }>;
+    validationErrors: Array<{
+        connectorId: string;
+        errors: string[];
+    }>;
+    trustSummary: Record<string, number>;
+    createdAt: string;
+}
+export declare class ConnectorInventoryLedger {
+    private obs;
+    constructor(obs: ObservabilityDatabase);
+    private now;
+    private generateId;
+    recordAudit(input: {
+        snapshotId: string;
+        scanned: number;
+        registered: number;
+        skipped: number;
+        conflicts?: Array<{
+            connectorId: string;
+            reason: string;
+        }>;
+        validationErrors?: Array<{
+            connectorId: string;
+            errors: string[];
+        }>;
+        trustSummary?: Record<string, number>;
+    }): Promise<string>;
+    getLatestAudit(snapshotId: string): Promise<InventorySnapshot | undefined>;
+    listAudits(opts?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<InventorySnapshot[]>;
+    private rowToSnapshot;
+}

package/runtime/observability/connector-inventory-ledger.js

@@ -0,0 +1,72 @@
+import { eq, desc } from "drizzle-orm";
+import { connectorInventoryAudit } from "./db/schema/index.js";
+export class ConnectorInventoryLedger {
+    obs;
+    constructor(obs) {
+        this.obs = obs;
+    }
+    now() {
+        return new Date().toISOString();
+    }
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+    }
+    async recordAudit(input) {
+        const auditId = this.generateId();
+        const createdAt = this.now();
+        await this.obs.db
+            .insert(connectorInventoryAudit)
+            .values({
+            auditId,
+            snapshotId: input.snapshotId,
+            scanned: input.scanned,
+            registered: input.registered,
+            skipped: input.skipped,
+            conflictsJson: JSON.stringify(input.conflicts ?? []),
+            validationErrorsJson: JSON.stringify(input.validationErrors ?? []),
+            trustSummaryJson: JSON.stringify(input.trustSummary ?? {}),
+            createdAt,
+        })
+            .execute();
+        return auditId;
+    }
+    async getLatestAudit(snapshotId) {
+        const result = await this.obs.db
+            .select()
+            .from(connectorInventoryAudit)
+            .where(eq(connectorInventoryAudit.snapshotId, snapshotId))
+            .orderBy(desc(connectorInventoryAudit.createdAt))
+            .limit(1)
+            .execute();
+        if (!result || result.length === 0)
+            return undefined;
+        const row = result[0];
+        return this.rowToSnapshot(row);
+    }
+    async listAudits(opts) {
+        const limit = opts?.limit ?? 100;
+        const offset = opts?.offset ?? 0;
+        const rows = await this.obs.db
+            .select()
+            .from(connectorInventoryAudit)
+            .orderBy(desc(connectorInventoryAudit.createdAt))
+            .limit(limit)
+            .offset(offset)
+            .execute();
+        return rows.map((r) => this.rowToSnapshot(r));
+    }
+    rowToSnapshot(row) {
+        const r = row;
+        return {
+            auditId: String(r.auditId),
+            snapshotId: String(r.snapshotId),
+            scanned: Number(r.scanned),
+            registered: Number(r.registered),
+            skipped: Number(r.skipped),
+            conflicts: JSON.parse(String(r.conflictsJson ?? "[]")),
+            validationErrors: JSON.parse(String(r.validationErrorsJson ?? "[]")),
+            trustSummary: JSON.parse(String(r.trustSummaryJson ?? "{}")),
+            createdAt: String(r.createdAt),
+        };
+    }
+}

package/runtime/observability/db/index.js

@@ -83,6 +83,19 @@ const OBSERVABILITY_SCHEMA_SQL = `
     conflict_records_json TEXT NOT NULL,
     full_report_json TEXT NOT NULL
   );
+  CREATE TABLE IF NOT EXISTS connector_inventory_audit (
+    audit_id TEXT PRIMARY KEY,
+    snapshot_id TEXT NOT NULL,
+    scanned INTEGER NOT NULL,
+    registered INTEGER NOT NULL,
+    skipped INTEGER NOT NULL,
+    conflicts_json TEXT NOT NULL,
+    validation_errors_json TEXT NOT NULL,
+    trust_summary_json TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS connector_inventory_snapshot_idx ON connector_inventory_audit(snapshot_id);
+  CREATE INDEX IF NOT EXISTS connector_inventory_created_at_idx ON connector_inventory_audit(created_at);
 `;
 function resolveDbPath(filename) {
     if (path.isAbsolute(filename) || filename === ":memory:") {