@stevenvincentone/intidev-agentloops 0.1.0

package/dist/postgres.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresStateBackend = exports.TICKET_SCHEMA_SQL = void 0;
+exports.serializeState = serializeState;
+exports.deserializeRows = deserializeRows;
+/**
+ * Public relational schema for the ledger. Faithfully mirrors `LoopState`:
+ * timestamps are stored as ISO text to keep round-trips identical to the JSON
+ * backend, and ordered child collections carry an `ord` column.
+ */
+exports.TICKET_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS loop_meta (
+  id integer PRIMARY KEY DEFAULT 1 CHECK (id = 1),
+  project text NOT NULL,
+  version integer NOT NULL,
+  created_at text NOT NULL,
+  updated_at text NOT NULL,
+  next_ticket_seq integer NOT NULL,
+  next_pattern_seq integer NOT NULL
+);
+CREATE TABLE IF NOT EXISTS ticket_patterns (
+  id text PRIMARY KEY,
+  family text NOT NULL,
+  title text NOT NULL,
+  status text NOT NULL,
+  created_at text NOT NULL,
+  updated_at text NOT NULL
+);
+CREATE TABLE IF NOT EXISTS tickets (
+  id text PRIMARY KEY,
+  family text NOT NULL,
+  kind text NOT NULL,
+  source text NOT NULL,
+  title text NOT NULL,
+  summary text NOT NULL,
+  severity text NOT NULL,
+  confidence text NOT NULL,
+  status text NOT NULL,
+  created_at text NOT NULL,
+  updated_at text NOT NULL,
+  started_at text,
+  resolved_at text,
+  handoff_text text,
+  guard_status text,
+  guard_summary text,
+  pattern_id text,
+  verification text,
+  reproducible boolean,
+  resolution_summary text
+);
+CREATE TABLE IF NOT EXISTS ticket_aliases (ticket_id text NOT NULL, alias text NOT NULL, ord integer NOT NULL);
+CREATE TABLE IF NOT EXISTS ticket_tags (ticket_id text NOT NULL, tag text NOT NULL, ord integer NOT NULL);
+CREATE TABLE IF NOT EXISTS ticket_notes (
+  id text NOT NULL,
+  ticket_id text NOT NULL,
+  type text NOT NULL,
+  body text NOT NULL,
+  author text,
+  created_at text NOT NULL,
+  ord integer NOT NULL
+);
+CREATE TABLE IF NOT EXISTS ticket_pattern_links (pattern_id text NOT NULL, ticket_id text NOT NULL, ord integer NOT NULL);
+`;
+/** Tables in dependency-free delete order (no FKs; order is for readability). */
+const TABLES = [
+    "ticket_pattern_links",
+    "ticket_notes",
+    "ticket_tags",
+    "ticket_aliases",
+    "tickets",
+    "ticket_patterns",
+    "loop_meta",
+];
+// --- Pure mapping (LoopState <-> relational rows), no DB -------------------
+function serializeState(state) {
+    const aliases = [];
+    const tags = [];
+    const notes = [];
+    const links = [];
+    for (const ticket of state.tickets) {
+        ticket.aliases.forEach((alias, ord) => aliases.push({ ticketId: ticket.id, alias, ord }));
+        ticket.tags.forEach((tag, ord) => tags.push({ ticketId: ticket.id, tag, ord }));
+        ticket.notes.forEach((note, ord) => notes.push({
+            id: note.id,
+            ticketId: ticket.id,
+            type: note.type,
+            body: note.body,
+            author: note.author ?? null,
+            createdAt: note.createdAt,
+            ord,
+        }));
+    }
+    for (const pattern of state.patterns) {
+        pattern.ticketIds.forEach((ticketId, ord) => links.push({ patternId: pattern.id, ticketId, ord }));
+    }
+    return {
+        meta: {
+            project: state.project,
+            version: state.version,
+            createdAt: state.createdAt,
+            updatedAt: state.updatedAt,
+            nextTicketSeq: state.nextTicketSeq,
+            nextPatternSeq: state.nextPatternSeq,
+        },
+        patterns: state.patterns.map((p) => ({
+            id: p.id,
+            family: p.family,
+            title: p.title,
+            status: p.status,
+            createdAt: p.createdAt,
+            updatedAt: p.updatedAt,
+        })),
+        tickets: state.tickets.map((t) => ({
+            id: t.id,
+            family: t.family,
+            kind: t.kind,
+            source: t.source,
+            title: t.title,
+            summary: t.summary,
+            severity: t.severity,
+            confidence: t.confidence,
+            status: t.status,
+            createdAt: t.createdAt,
+            updatedAt: t.updatedAt,
+            startedAt: t.startedAt ?? null,
+            resolvedAt: t.resolvedAt ?? null,
+            handoffText: t.handoffText ?? null,
+            guardStatus: t.guardStatus ?? null,
+            guardSummary: t.guardSummary ?? null,
+            patternId: t.patternId ?? null,
+            verification: t.verification ?? null,
+            reproducible: t.reproducible ?? null,
+            resolutionSummary: t.resolutionSummary ?? null,
+        })),
+        aliases,
+        tags,
+        notes,
+        links,
+    };
+}
+function byOrd(a, b) {
+    return a.ord - b.ord;
+}
+function deserializeRows(rows) {
+    const aliasesByTicket = new Map();
+    for (const a of rows.aliases)
+        (aliasesByTicket.get(a.ticketId) ?? aliasesByTicket.set(a.ticketId, []).get(a.ticketId)).push(a);
+    const tagsByTicket = new Map();
+    for (const t of rows.tags)
+        (tagsByTicket.get(t.ticketId) ?? tagsByTicket.set(t.ticketId, []).get(t.ticketId)).push(t);
+    const notesByTicket = new Map();
+    for (const n of rows.notes)
+        (notesByTicket.get(n.ticketId) ?? notesByTicket.set(n.ticketId, []).get(n.ticketId)).push(n);
+    const linksByPattern = new Map();
+    for (const l of rows.links)
+        (linksByPattern.get(l.patternId) ?? linksByPattern.set(l.patternId, []).get(l.patternId)).push(l);
+    const tickets = rows.tickets.map((row) => {
+        const ticket = {
+            id: row.id,
+            family: row.family,
+            kind: row.kind,
+            source: row.source,
+            title: row.title,
+            summary: row.summary,
+            severity: row.severity,
+            confidence: row.confidence,
+            status: row.status,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+            aliases: (aliasesByTicket.get(row.id) ?? []).sort(byOrd).map((a) => a.alias),
+            tags: (tagsByTicket.get(row.id) ?? []).sort(byOrd).map((t) => t.tag),
+            notes: (notesByTicket.get(row.id) ?? []).sort(byOrd).map((n) => {
+                const note = {
+                    id: n.id,
+                    type: n.type,
+                    body: n.body,
+                    createdAt: n.createdAt,
+                };
+                if (n.author != null)
+                    note.author = n.author;
+                return note;
+            }),
+        };
+        if (row.startedAt != null)
+            ticket.startedAt = row.startedAt;
+        if (row.resolvedAt != null)
+            ticket.resolvedAt = row.resolvedAt;
+        if (row.handoffText != null)
+            ticket.handoffText = row.handoffText;
+        if (row.guardStatus != null)
+            ticket.guardStatus = row.guardStatus;
+        if (row.guardSummary != null)
+            ticket.guardSummary = row.guardSummary;
+        if (row.patternId != null)
+            ticket.patternId = row.patternId;
+        if (row.verification != null)
+            ticket.verification = row.verification;
+        if (row.reproducible != null)
+            ticket.reproducible = row.reproducible;
+        if (row.resolutionSummary != null)
+            ticket.resolutionSummary = row.resolutionSummary;
+        return ticket;
+    });
+    const patterns = rows.patterns.map((row) => ({
+        id: row.id,
+        family: row.family,
+        title: row.title,
+        status: row.status,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        ticketIds: (linksByPattern.get(row.id) ?? []).sort(byOrd).map((l) => l.ticketId),
+    }));
+    return {
+        version: rows.meta.version,
+        project: rows.meta.project,
+        createdAt: rows.meta.createdAt,
+        updatedAt: rows.meta.updatedAt,
+        nextTicketSeq: rows.meta.nextTicketSeq,
+        nextPatternSeq: rows.meta.nextPatternSeq,
+        tickets,
+        patterns,
+    };
+}
+function isPool(client) {
+    return typeof client.connect === "function";
+}
+/**
+ * Postgres-backed `StateBackend` over the relational `ticket_*` schema. Brings
+ * no `pg` dependency — the host injects a `pg.Pool`/`pg.Client`-shaped client.
+ * Saves are transactional (whole-snapshot replace), so a failed write never
+ * leaves a partially-updated ledger.
+ */
+class PostgresStateBackend {
+    client;
+    migrated = false;
+    constructor(client) {
+        this.client = client;
+    }
+    async migrate() {
+        await this.client.query(exports.TICKET_SCHEMA_SQL);
+        this.migrated = true;
+    }
+    async ensureSchema() {
+        if (!this.migrated)
+            await this.migrate();
+    }
+    async withConnection(run) {
+        if (isPool(this.client)) {
+            const conn = await this.client.connect();
+            try {
+                return await run(conn);
+            }
+            finally {
+                conn.release();
+            }
+        }
+        return run(this.client);
+    }
+    async load() {
+        await this.ensureSchema();
+        return this.withConnection(async (c) => {
+            const meta = (await c.query("SELECT * FROM loop_meta WHERE id = 1")).rows[0];
+            if (!meta)
+                return null;
+            const patterns = (await c.query("SELECT * FROM ticket_patterns ORDER BY id")).rows;
+            const tickets = (await c.query("SELECT * FROM tickets ORDER BY id")).rows;
+            const aliases = (await c.query("SELECT * FROM ticket_aliases ORDER BY ticket_id, ord")).rows;
+            const tags = (await c.query("SELECT * FROM ticket_tags ORDER BY ticket_id, ord")).rows;
+            const notes = (await c.query("SELECT * FROM ticket_notes ORDER BY ticket_id, ord")).rows;
+            const links = (await c.query("SELECT * FROM ticket_pattern_links ORDER BY pattern_id, ord")).rows;
+            const rows = {
+                meta: {
+                    project: String(meta.project),
+                    version: Number(meta.version),
+                    createdAt: String(meta.created_at),
+                    updatedAt: String(meta.updated_at),
+                    nextTicketSeq: Number(meta.next_ticket_seq),
+                    nextPatternSeq: Number(meta.next_pattern_seq),
+                },
+                patterns: patterns.map((r) => ({
+                    id: String(r.id),
+                    family: String(r.family),
+                    title: String(r.title),
+                    status: String(r.status),
+                    createdAt: String(r.created_at),
+                    updatedAt: String(r.updated_at),
+                })),
+                tickets: tickets.map((r) => ({
+                    id: String(r.id),
+                    family: String(r.family),
+                    kind: String(r.kind),
+                    source: String(r.source),
+                    title: String(r.title),
+                    summary: String(r.summary),
+                    severity: String(r.severity),
+                    confidence: String(r.confidence),
+                    status: String(r.status),
+                    createdAt: String(r.created_at),
+                    updatedAt: String(r.updated_at),
+                    startedAt: r.started_at ?? null,
+                    resolvedAt: r.resolved_at ?? null,
+                    handoffText: r.handoff_text ?? null,
+                    guardStatus: r.guard_status ?? null,
+                    guardSummary: r.guard_summary ?? null,
+                    patternId: r.pattern_id ?? null,
+                    verification: r.verification ?? null,
+                    reproducible: r.reproducible ?? null,
+                    resolutionSummary: r.resolution_summary ?? null,
+                })),
+                aliases: aliases.map((r) => ({ ticketId: String(r.ticket_id), alias: String(r.alias), ord: Number(r.ord) })),
+                tags: tags.map((r) => ({ ticketId: String(r.ticket_id), tag: String(r.tag), ord: Number(r.ord) })),
+                notes: notes.map((r) => ({
+                    id: String(r.id),
+                    ticketId: String(r.ticket_id),
+                    type: String(r.type),
+                    body: String(r.body),
+                    author: r.author ?? null,
+                    createdAt: String(r.created_at),
+                    ord: Number(r.ord),
+                })),
+                links: links.map((r) => ({ patternId: String(r.pattern_id), ticketId: String(r.ticket_id), ord: Number(r.ord) })),
+            };
+            return deserializeRows(rows);
+        });
+    }
+    async save(state) {
+        await this.ensureSchema();
+        const rows = serializeState(state);
+        await this.withConnection(async (c) => {
+            await c.query("BEGIN");
+            try {
+                for (const table of TABLES)
+                    await c.query(`DELETE FROM ${table}`);
+                await c.query("INSERT INTO loop_meta (id, project, version, created_at, updated_at, next_ticket_seq, next_pattern_seq) VALUES (1, $1, $2, $3, $4, $5, $6)", [rows.meta.project, rows.meta.version, rows.meta.createdAt, rows.meta.updatedAt, rows.meta.nextTicketSeq, rows.meta.nextPatternSeq]);
+                for (const p of rows.patterns) {
+                    await c.query("INSERT INTO ticket_patterns (id, family, title, status, created_at, updated_at) VALUES ($1, $2, $3, $4, $5, $6)", [p.id, p.family, p.title, p.status, p.createdAt, p.updatedAt]);
+                }
+                for (const t of rows.tickets) {
+                    await c.query(`INSERT INTO tickets (id, family, kind, source, title, summary, severity, confidence, status, created_at, updated_at, started_at, resolved_at, handoff_text, guard_status, guard_summary, pattern_id, verification, reproducible, resolution_summary)
+             VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20)`, [t.id, t.family, t.kind, t.source, t.title, t.summary, t.severity, t.confidence, t.status, t.createdAt, t.updatedAt, t.startedAt, t.resolvedAt, t.handoffText, t.guardStatus, t.guardSummary, t.patternId, t.verification, t.reproducible, t.resolutionSummary]);
+                }
+                for (const a of rows.aliases) {
+                    await c.query("INSERT INTO ticket_aliases (ticket_id, alias, ord) VALUES ($1, $2, $3)", [a.ticketId, a.alias, a.ord]);
+                }
+                for (const tag of rows.tags) {
+                    await c.query("INSERT INTO ticket_tags (ticket_id, tag, ord) VALUES ($1, $2, $3)", [tag.ticketId, tag.tag, tag.ord]);
+                }
+                for (const n of rows.notes) {
+                    await c.query("INSERT INTO ticket_notes (id, ticket_id, type, body, author, created_at, ord) VALUES ($1, $2, $3, $4, $5, $6, $7)", [n.id, n.ticketId, n.type, n.body, n.author, n.createdAt, n.ord]);
+                }
+                for (const l of rows.links) {
+                    await c.query("INSERT INTO ticket_pattern_links (pattern_id, ticket_id, ord) VALUES ($1, $2, $3)", [l.patternId, l.ticketId, l.ord]);
+                }
+                await c.query("COMMIT");
+            }
+            catch (error) {
+                await c.query("ROLLBACK");
+                throw error;
+            }
+        });
+    }
+}
+exports.PostgresStateBackend = PostgresStateBackend;
+//# sourceMappingURL=postgres.js.map

package/dist/prior-art.d.ts

@@ -0,0 +1,65 @@
+import { Ticket } from "./types";
+export declare const PRIOR_ART_SCHEMA_VERSION: 1;
+/**
+ * Weights for the deterministic relatedness signals. Fixed defaults live in core
+ * (keeping behavior deterministic per the extraction principles) but a project
+ * can override any of them via `config.priorArt.weights`.
+ */
+export interface PriorArtWeights {
+    /** Same family. */
+    family: number;
+    /** Belongs to the same Pattern. */
+    pattern: number;
+    /** Per shared tag. */
+    tag: number;
+    /** Same ticket kind. */
+    kind: number;
+    /** Multiplied by the title/summary token overlap (Jaccard, 0..1). */
+    textOverlap: number;
+}
+export declare const DEFAULT_PRIOR_ART_WEIGHTS: PriorArtWeights;
+export interface PriorArtOptions {
+    weights?: Partial<PriorArtWeights>;
+    /** Minimum score for a candidate to be considered related. Default 1. */
+    minScore?: number;
+    /** Maximum related tickets to return. Default 10. */
+    limit?: number;
+}
+export interface RelatedTicket {
+    id: string;
+    alias: string;
+    kind: string;
+    source: string;
+    family: string;
+    status: string;
+    title: string;
+    score: number;
+    /** Human-readable evidence for the edge, e.g. ["family", "tag:export", "text:0.42"]. */
+    signals: string[];
+}
+export interface PriorArtReport {
+    schemaVersion: typeof PRIOR_ART_SCHEMA_VERSION;
+    generatedAt: string;
+    ticket: {
+        id: string;
+        alias: string;
+        family: string;
+        kind: string;
+        title: string;
+    };
+    weights: PriorArtWeights;
+    filters: {
+        minScore: number;
+        limit: number;
+    };
+    related: RelatedTicket[];
+}
+/**
+ * Prior-art lookup (ported concept from Inti's relationship graph): rank the
+ * tickets most related to `targetId` using deterministic signals — shared
+ * family, shared Pattern, shared tags, same kind, and title/summary token
+ * overlap — each contributing a configurable weight.
+ *
+ * Pure and deterministic apart from `generatedAt`.
+ */
+export declare function relatedTickets(targetId: string, tickets: Ticket[], options?: PriorArtOptions): PriorArtReport;

package/dist/prior-art.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PRIOR_ART_WEIGHTS = exports.PRIOR_ART_SCHEMA_VERSION = void 0;
+exports.relatedTickets = relatedTickets;
+exports.PRIOR_ART_SCHEMA_VERSION = 1;
+exports.DEFAULT_PRIOR_ART_WEIGHTS = {
+    family: 3,
+    pattern: 3,
+    tag: 2,
+    kind: 1,
+    textOverlap: 4,
+};
+const STOP_TOKEN_MIN_LENGTH = 3;
+function tokenize(text) {
+    return new Set(text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((token) => token.length >= STOP_TOKEN_MIN_LENGTH));
+}
+function jaccard(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const token of a)
+        if (b.has(token))
+            intersection += 1;
+    const union = a.size + b.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+}
+function round(value) {
+    return Math.round(value * 100) / 100;
+}
+/**
+ * Prior-art lookup (ported concept from Inti's relationship graph): rank the
+ * tickets most related to `targetId` using deterministic signals — shared
+ * family, shared Pattern, shared tags, same kind, and title/summary token
+ * overlap — each contributing a configurable weight.
+ *
+ * Pure and deterministic apart from `generatedAt`.
+ */
+function relatedTickets(targetId, tickets, options = {}) {
+    const weights = { ...exports.DEFAULT_PRIOR_ART_WEIGHTS, ...options.weights };
+    const minScore = options.minScore ?? 1;
+    const limit = options.limit ?? 10;
+    const target = tickets.find((ticket) => ticket.id === targetId);
+    if (!target) {
+        throw new Error(`Not found: ${targetId}`);
+    }
+    const targetTokens = tokenize(`${target.title} ${target.summary}`);
+    const targetTags = new Set(target.tags);
+    const related = [];
+    for (const candidate of tickets) {
+        if (candidate.id === target.id)
+            continue;
+        let score = 0;
+        const signals = [];
+        if (weights.family && candidate.family === target.family) {
+            score += weights.family;
+            signals.push("family");
+        }
+        if (weights.pattern && candidate.patternId && candidate.patternId === target.patternId) {
+            score += weights.pattern;
+            signals.push("pattern");
+        }
+        if (weights.tag) {
+            for (const tag of candidate.tags) {
+                if (targetTags.has(tag)) {
+                    score += weights.tag;
+                    signals.push(`tag:${tag}`);
+                }
+            }
+        }
+        if (weights.kind && candidate.kind === target.kind) {
+            score += weights.kind;
+            signals.push("kind");
+        }
+        if (weights.textOverlap) {
+            const overlap = jaccard(targetTokens, tokenize(`${candidate.title} ${candidate.summary}`));
+            if (overlap > 0) {
+                score += weights.textOverlap * overlap;
+                signals.push(`text:${overlap.toFixed(2)}`);
+            }
+        }
+        if (score >= minScore) {
+            related.push({
+                id: candidate.id,
+                alias: candidate.aliases[0] ?? candidate.id,
+                kind: candidate.kind,
+                source: candidate.source,
+                family: candidate.family,
+                status: candidate.status,
+                title: candidate.title,
+                score: round(score),
+                signals,
+            });
+        }
+    }
+    related.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+    return {
+        schemaVersion: exports.PRIOR_ART_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        ticket: {
+            id: target.id,
+            alias: target.aliases[0] ?? target.id,
+            family: target.family,
+            kind: target.kind,
+            title: target.title,
+        },
+        weights,
+        filters: { minScore, limit },
+        related: related.slice(0, limit),
+    };
+}
+//# sourceMappingURL=prior-art.js.map

package/dist/redaction.d.ts

@@ -0,0 +1,14 @@
+import { ProjectConfig, RedactionRule, TicketRedactor } from "./types";
+/** Identity redactor — stores content unchanged. The default. */
+export declare const noopRedactor: TicketRedactor;
+/**
+ * Build a redactor from a list of regex rules. Each rule's pattern is replaced
+ * with its `replacement` (default `[redacted]`). `redactJson` walks structures
+ * and redacts every string leaf.
+ */
+export declare function createPatternRedactor(rules: RedactionRule[]): TicketRedactor;
+/**
+ * Resolve the redactor to use: an explicit override wins; otherwise build one
+ * from `config.redaction.patterns`; otherwise the no-op redactor.
+ */
+export declare function resolveRedactor(config: ProjectConfig, override?: TicketRedactor): TicketRedactor;

package/dist/redaction.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noopRedactor = void 0;
+exports.createPatternRedactor = createPatternRedactor;
+exports.resolveRedactor = resolveRedactor;
+/** Identity redactor — stores content unchanged. The default. */
+exports.noopRedactor = {
+    redactText: (value) => value,
+    redactJson: (value) => value,
+};
+/**
+ * Build a redactor from a list of regex rules. Each rule's pattern is replaced
+ * with its `replacement` (default `[redacted]`). `redactJson` walks structures
+ * and redacts every string leaf.
+ */
+function createPatternRedactor(rules) {
+    const compiled = rules.map((rule) => ({
+        regex: new RegExp(rule.pattern, rule.flags ?? "g"),
+        replacement: rule.replacement ?? "[redacted]",
+    }));
+    const redactText = (value) => {
+        let out = value;
+        for (const { regex, replacement } of compiled) {
+            regex.lastIndex = 0;
+            out = out.replace(regex, replacement);
+        }
+        return out;
+    };
+    const redactJson = (value) => {
+        if (typeof value === "string")
+            return redactText(value);
+        if (Array.isArray(value))
+            return value.map(redactJson);
+        if (value && typeof value === "object") {
+            const out = {};
+            for (const [key, val] of Object.entries(value)) {
+                out[key] = redactJson(val);
+            }
+            return out;
+        }
+        return value;
+    };
+    return { redactText, redactJson };
+}
+/**
+ * Resolve the redactor to use: an explicit override wins; otherwise build one
+ * from `config.redaction.patterns`; otherwise the no-op redactor.
+ */
+function resolveRedactor(config, override) {
+    if (override)
+        return override;
+    const rules = config.redaction?.patterns;
+    if (rules && rules.length > 0)
+        return createPatternRedactor(rules);
+    return exports.noopRedactor;
+}
+//# sourceMappingURL=redaction.js.map

package/dist/serve.d.ts

@@ -0,0 +1,8 @@
+import { type Server } from "node:http";
+import { AgentLoopStore } from "./store";
+/**
+ * A zero-dependency HTTP server that renders the dashboard at `/` and exposes
+ * read-only JSON at `/api/*`, re-reading the store on each request (so it
+ * reflects the live ledger over filesystem or Postgres).
+ */
+export declare function createDashboardServer(store: AgentLoopStore): Server;

package/dist/serve.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDashboardServer = createDashboardServer;
+const node_http_1 = require("node:http");
+const dashboard_1 = require("./dashboard");
+function sendJson(res, value) {
+    res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(value, null, 2));
+}
+async function handle(store, req, res) {
+    const url = (req.url ?? "/").split("?")[0];
+    try {
+        if (url === "/api/summary")
+            return sendJson(res, await store.summary());
+        if (url === "/api/tickets")
+            return sendJson(res, await store.listTickets({ status: "all" }));
+        if (url === "/api/patterns")
+            return sendJson(res, await store.listPatterns({ status: "all" }));
+        if (url === "/api/convergence") {
+            return sendJson(res, await store.sourceConvergence({ includeAll: true }));
+        }
+        if (url === "/api/guard-gaps")
+            return sendJson(res, await store.guardGaps({}));
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        res.end((0, dashboard_1.renderDashboard)(await (0, dashboard_1.gatherDashboardData)(store)));
+    }
+    catch (error) {
+        res.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+        res.end(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * A zero-dependency HTTP server that renders the dashboard at `/` and exposes
+ * read-only JSON at `/api/*`, re-reading the store on each request (so it
+ * reflects the live ledger over filesystem or Postgres).
+ */
+function createDashboardServer(store) {
+    return (0, node_http_1.createServer)((req, res) => {
+        void handle(store, req, res);
+    });
+}
+//# sourceMappingURL=serve.js.map

package/dist/storage.d.ts

@@ -0,0 +1,22 @@
+import { ProjectConfig } from "./types";
+import { StateBackend } from "./backend";
+export interface BackendSelection {
+    backend: StateBackend;
+    kind: "filesystem" | "postgres";
+    /** Release any held resources (e.g. close the Postgres pool). */
+    dispose(): Promise<void>;
+}
+export interface ResolveBackendOptions {
+    cwd: string;
+    config: ProjectConfig;
+    /** Explicit connection string; overrides env and config. */
+    databaseUrl?: string;
+}
+/** Connection string precedence: explicit arg → `DATABASE_URL` env → config. */
+export declare function resolvePostgresUrl(options: ResolveBackendOptions): string | undefined;
+/**
+ * Pick a `StateBackend` for the CLI/MCP: Postgres when a connection string is
+ * configured, otherwise the filesystem. `pg` is loaded lazily and is an optional
+ * peer dependency — filesystem users never need it.
+ */
+export declare function resolveBackend(options: ResolveBackendOptions): Promise<BackendSelection>;