@aitne/daemon 0.1.8 → 0.1.9

package/dist/db/agents-store.js

@@ -0,0 +1,264 @@
+// ── JSON parsing (defensive — store is the writer, but never trust bytes) ──
+function parseTags(json) {
+    try {
+        const parsed = JSON.parse(json);
+        if (Array.isArray(parsed)) {
+            return parsed.filter((v) => typeof v === "string");
+        }
+    }
+    catch {
+        /* fall through to [] */
+    }
+    return [];
+}
+function parseStopWarning(json) {
+    if (json === null)
+        return null;
+    try {
+        const parsed = JSON.parse(json);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        /* fall through to null */
+    }
+    return null;
+}
+function parseMetadata(json) {
+    try {
+        const parsed = JSON.parse(json);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        /* fall through to {} */
+    }
+    return {};
+}
+function rowToDTO(row) {
+    const metadata = parseMetadata(row.metadata_json);
+    // Read into a local first: the redaction static guard
+    // (scripts/check-redaction-coverage.mjs) flags the auth-health JSON key name
+    // whenever it is immediately followed by an equals sign anywhere under
+    // daemon/src, to force the `backends` auth-detail column through its
+    // redaction helper. The metadata key read just below is an unrelated
+    // Agent-definition parse error (§6.6), never a secret — so we dodge the
+    // textual pattern by comparing the camelCase local rather than exempting the
+    // whole file. Do NOT inline this back into the comparison.
+    const lastError = metadata.last_error;
+    return {
+        slug: row.id,
+        name: row.name,
+        description: row.description,
+        source: row.source,
+        definitionPath: row.definition_path,
+        definitionHash: row.definition_hash,
+        enabled: row.enabled === 1,
+        enabledOverriddenAt: row.enabled_overridden_at,
+        processKey: row.process_key,
+        scheduleKind: row.schedule_kind,
+        scheduleExpression: row.schedule_expression,
+        scheduleTimezone: row.schedule_timezone,
+        tags: parseTags(row.tags_json),
+        stopWarning: parseStopWarning(row.stop_warning_json),
+        recurringScheduleId: row.recurring_schedule_id,
+        lastExecutionId: row.last_execution_id,
+        metadata,
+        invalid: typeof lastError === "string" && lastError.length > 0,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+// ── Reads ────────────────────────────────────────────────────────────
+export function getAgent(db, slug) {
+    const row = db
+        .prepare("SELECT * FROM agents WHERE id = ?")
+        .get(slug);
+    return row ? rowToDTO(row) : null;
+}
+export function listAgents(db, filter = {}) {
+    const where = [];
+    const params = [];
+    if (filter.source !== undefined) {
+        where.push("source = ?");
+        params.push(filter.source);
+    }
+    if (filter.enabled !== undefined) {
+        where.push("enabled = ?");
+        params.push(filter.enabled ? 1 : 0);
+    }
+    if (filter.includeInvalid === false) {
+        // metadata_json is always valid JSON written by this store (default '{}'),
+        // so json_extract is safe. An absent key returns NULL → the row is kept.
+        where.push("json_extract(metadata_json, '$.last_error') IS NULL");
+    }
+    const sql = "SELECT * FROM agents"
+        + (where.length ? ` WHERE ${where.join(" AND ")}` : "")
+        + " ORDER BY source ASC, id ASC";
+    const rows = db.prepare(sql).all(...params);
+    return rows.map(rowToDTO);
+}
+// ── Writes ───────────────────────────────────────────────────────────
+/**
+ * Insert or update an Agent identity row by slug. On conflict, `created_at`
+ * and `last_execution_id` are preserved (not in the DO UPDATE set); every
+ * other column is overwritten from `input`. Returns the resulting DTO.
+ */
+export function upsertAgent(db, input, now = Date.now()) {
+    db.prepare(`INSERT INTO agents (
+        id, name, description, source, definition_path, definition_hash,
+        enabled, enabled_overridden_at, process_key, schedule_kind,
+        schedule_expression, schedule_timezone, tags_json, stop_warning_json,
+        recurring_schedule_id, metadata_json, created_at, updated_at
+     ) VALUES (
+        @id, @name, @description, @source, @definition_path, @definition_hash,
+        @enabled, @enabled_overridden_at, @process_key, @schedule_kind,
+        @schedule_expression, @schedule_timezone, @tags_json, @stop_warning_json,
+        @recurring_schedule_id, @metadata_json, @created_at, @updated_at
+     )
+     ON CONFLICT(id) DO UPDATE SET
+        name = excluded.name,
+        description = excluded.description,
+        source = excluded.source,
+        definition_path = excluded.definition_path,
+        definition_hash = excluded.definition_hash,
+        enabled = excluded.enabled,
+        enabled_overridden_at = excluded.enabled_overridden_at,
+        process_key = excluded.process_key,
+        schedule_kind = excluded.schedule_kind,
+        schedule_expression = excluded.schedule_expression,
+        schedule_timezone = excluded.schedule_timezone,
+        tags_json = excluded.tags_json,
+        stop_warning_json = excluded.stop_warning_json,
+        recurring_schedule_id = excluded.recurring_schedule_id,
+        metadata_json = excluded.metadata_json,
+        updated_at = excluded.updated_at`).run({
+        id: input.slug,
+        name: input.name,
+        description: input.description ?? null,
+        source: input.source,
+        definition_path: input.definitionPath,
+        definition_hash: input.definitionHash,
+        enabled: input.enabled ? 1 : 0,
+        enabled_overridden_at: input.enabledOverriddenAt ?? null,
+        process_key: input.processKey ?? null,
+        schedule_kind: input.scheduleKind,
+        schedule_expression: input.scheduleExpression ?? null,
+        schedule_timezone: input.scheduleTimezone,
+        tags_json: JSON.stringify(input.tags ?? []),
+        stop_warning_json: input.stopWarning != null ? JSON.stringify(input.stopWarning) : null,
+        recurring_schedule_id: input.recurringScheduleId ?? null,
+        metadata_json: JSON.stringify(input.metadata ?? {}),
+        created_at: now,
+        updated_at: now,
+    });
+    // Non-null: the row was just inserted/updated under this id.
+    return getAgent(db, input.slug);
+}
+/**
+ * Toggle the enabled flag and stamp `enabled_overridden_at` (the dashboard
+ * PATCH path, §6.4 / §9.5). Pass `overriddenAt = now` for an operator toggle;
+ * the loader never calls this (it writes enabled via `upsertAgent`). Returns
+ * the updated DTO, or `null` when no row matches the slug.
+ */
+export function setEnabled(db, slug, enabled, overriddenAt, now = Date.now()) {
+    const result = db
+        .prepare(`UPDATE agents
+          SET enabled = ?, enabled_overridden_at = ?, updated_at = ?
+        WHERE id = ?`)
+        .run(enabled ? 1 : 0, overriddenAt, now, slug);
+    if (result.changes === 0)
+        return null;
+    return getAgent(db, slug);
+}
+/**
+ * Point `last_execution_id` at a freshly-recorded execution (the recorder
+ * runs this inside the same transaction as `completeExecution`, §8.2).
+ * `null` clears the pointer. Returns true when a row was updated.
+ */
+export function setLastExecutionId(db, slug, executionId, now = Date.now()) {
+    const result = db
+        .prepare(`UPDATE agents SET last_execution_id = ?, updated_at = ? WHERE id = ?`)
+        .run(executionId, now, slug);
+    return result.changes > 0;
+}
+// ── One-shot Agent lifecycle (legacy / defensive) ──────────────────────────
+/**
+ * Defensive cleanup for any row that still carries `schedule_kind='one_shot'`.
+ *
+ * As of the scheduling split, `/agents` is recurring-only — the loader rejects
+ * a user one_shot definition outright, so no NEW one_shot Agents are created.
+ * This guard is retained because a legacy/pre-split DB row (or a manual edit)
+ * could still be `one_shot`: when such a row fires, disable it (so it stays as a
+ * re-runnable record the operator can re-fire via run-now) and skip any other
+ * still-pending firing for it (defends against a run-now + scheduled pair, or a
+ * stale row, double-firing). No-op for cron / event Agents — they keep their
+ * materialised pending rows. Returns true only when this call disabled a
+ * still-enabled one_shot Agent. Called unconditionally by the execution
+ * recorder; the `schedule_kind !== 'one_shot'` guard makes it a cheap no-op for
+ * the now-universal cron case.
+ */
+export function disableOneShotAfterFire(db, slug, now = Date.now()) {
+    const row = db
+        .prepare("SELECT schedule_kind AS schedule_kind, enabled AS enabled FROM agents WHERE id = ?")
+        .get(slug);
+    if (!row || row.schedule_kind !== "one_shot")
+        return false;
+    // Cancel sibling pending fires so a double-booked one_shot can't fire twice
+    // once one run has settled — independent of the enabled flip below.
+    db.prepare(`UPDATE agent_schedule SET status = 'skipped'
+       WHERE json_extract(task_context, '$.agent_id') = ? AND status = 'pending'`).run(slug);
+    if (row.enabled === 0)
+        return false;
+    db.prepare(`UPDATE agents
+        SET enabled = 0, enabled_overridden_at = ?, updated_at = ?
+      WHERE id = ? AND enabled = 1`).run(now, now, slug);
+    return true;
+}
+/**
+ * Delete an Agent row. The FK on `agent_executions.agent_id` cascades, so the
+ * Agent's execution history is removed too (the `/api/agents` DELETE handler's
+ * `keep_history` path stops short of this and disables instead — §9.6).
+ * Returns true when a row was removed.
+ */
+export function deleteAgent(db, slug) {
+    const result = db.prepare("DELETE FROM agents WHERE id = ?").run(slug);
+    return result.changes > 0;
+}
+// ── Override snapshot (§6.4.1 — built-in edits that survive npm upgrade) ──
+/**
+ * Read the built-in override snapshot. Returns `{}` when the Agent is missing
+ * or carries no snapshot, so callers can treat the result uniformly.
+ */
+export function getOverrideSnapshot(db, slug) {
+    const row = db
+        .prepare("SELECT metadata_json FROM agents WHERE id = ?")
+        .get(slug);
+    if (!row)
+        return {};
+    return parseMetadata(row.metadata_json).override_snapshot ?? {};
+}
+/**
+ * Replace the override snapshot, preserving every other `metadata_json` key.
+ * An empty snapshot removes the `override_snapshot` key entirely (so a fully
+ * reset Agent's metadata is clean). Returns the updated DTO, or `null` when no
+ * row matches.
+ */
+export function setOverrideSnapshot(db, slug, snapshot, now = Date.now()) {
+    const row = db
+        .prepare("SELECT metadata_json FROM agents WHERE id = ?")
+        .get(slug);
+    if (!row)
+        return null;
+    const metadata = parseMetadata(row.metadata_json);
+    if (Object.keys(snapshot).length === 0) {
+        delete metadata.override_snapshot;
+    }
+    else {
+        metadata.override_snapshot = snapshot;
+    }
+    db.prepare("UPDATE agents SET metadata_json = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(metadata), now, slug);
+    return getAgent(db, slug);
+}

package/dist/db/automation-triggers.d.ts

@@ -87,4 +87,3 @@ export declare function getCatalog(domain: TriggerDomain): {
     events: CatalogEvent[];
 };
 export type { RecurringScheduleDTO };
-//# sourceMappingURL=automation-triggers.d.ts.map

package/dist/db/automation-triggers.js

@@ -196,4 +196,3 @@ export function getCatalog(domain) {
     }
     return { domain, events: [] };
 }
-//# sourceMappingURL=automation-triggers.js.map

package/dist/db/browser-automation-b4-config-store.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Browser Automation B-4 site config — per-`site_key` enable flag +
+ * per-day caps. Plus the global B-4 master toggle stored in
+ * `runtime_state`.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.8 / §13 steps 55, 59.
+ *
+ * The handler reads `getB4Enabled()` first — if false the runner-level
+ * outcome is `purchase_b4_disabled` before any DB write. Then it reads
+ * `getSiteB4Config(siteKey)` to confirm the site has been opted-in by
+ * the user via the dashboard. The atomic cap enforcement lives in
+ * `browser-automation-purchase-tokens-store.issuePurchaseToken` — this
+ * module is the CRUD surface for the dashboard.
+ *
+ * Excluded from the 100% coverage gate — prepared statements + runtime
+ * state KV reads.
+ */
+import type Database from "better-sqlite3";
+export interface B4SiteConfigRow {
+    siteKey: string;
+    enabled: boolean;
+    currency: string;
+    dailyTokenCap: number;
+    dailySpendCapMinor: number;
+    perTxCapMinorOverride: number | null;
+    updatedAt: number;
+}
+/** Read the global B-4 master toggle. Off (false) when the row is
+ *  absent — that's the default for every install. The value is
+ *  persisted as JSON-encoded boolean so future shape extensions
+ *  (e.g., enabled-since-when, enabled-by-which-user) can attach
+ *  without a key rename. */
+export declare function getB4Enabled(db: Database.Database): boolean;
+/** Atomic write of the global toggle. The dashboard's enable-modal
+ *  flow flips this to true AFTER the user clicks through the
+ *  experimental-danger acknowledgement. */
+export declare function setB4Enabled(db: Database.Database, enabled: boolean): void;
+export declare function getSiteB4Config(db: Database.Database, siteKey: string): B4SiteConfigRow | null;
+export declare function listSiteB4Configs(db: Database.Database): B4SiteConfigRow[];
+export interface UpsertB4SiteConfigInput {
+    siteKey: string;
+    enabled: boolean;
+    currency: string;
+    dailyTokenCap?: number;
+    dailySpendCapMinor?: number;
+    perTxCapMinorOverride?: number | null;
+    updatedAt: number;
+}
+/**
+ * INSERT OR REPLACE the per-site row. The route layer validates the
+ * cap shapes (Zod) before calling; the schema's CHECK constraints
+ * are the structural floor.
+ *
+ * The currency field is meaningful — the issuance path refuses any
+ * workflow whose `params.currency` does not equal the configured
+ * currency. Changing the currency mid-config is permitted (the
+ * dashboard surfaces a confirmation when the user does so); the
+ * audit row on `browser_automation_workflows` carries the
+ * `currency_mismatch` cancel reason if a stale in-flight token hits
+ * the new shape.
+ */
+export declare function upsertSiteB4Config(db: Database.Database, input: UpsertB4SiteConfigInput): B4SiteConfigRow;
+/**
+ * Delete the row. Called by the dashboard's "Disable B-4" destructive
+ * flow alongside the global toggle reset. After deletion the site
+ * cannot mint tokens until the user re-enables it.
+ */
+export declare function deleteSiteB4Config(db: Database.Database, siteKey: string): number;

package/dist/db/browser-automation-b4-config-store.js

@@ -0,0 +1,111 @@
+/**
+ * Browser Automation B-4 site config — per-`site_key` enable flag +
+ * per-day caps. Plus the global B-4 master toggle stored in
+ * `runtime_state`.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.8 / §13 steps 55, 59.
+ *
+ * The handler reads `getB4Enabled()` first — if false the runner-level
+ * outcome is `purchase_b4_disabled` before any DB write. Then it reads
+ * `getSiteB4Config(siteKey)` to confirm the site has been opted-in by
+ * the user via the dashboard. The atomic cap enforcement lives in
+ * `browser-automation-purchase-tokens-store.issuePurchaseToken` — this
+ * module is the CRUD surface for the dashboard.
+ *
+ * Excluded from the 100% coverage gate — prepared statements + runtime
+ * state KV reads.
+ */
+import { B4_DEFAULT_DAILY_SPEND_CAP_MINOR, B4_DEFAULT_DAILY_TOKEN_CAP, MANAGED_CHROMIUM_B4_ENABLED_KEY, } from "../services/browser-history/managed-chromium/types.js";
+import { readRuntimeState, writeRuntimeState } from "./runtime-state.js";
+function fromDbRow(row) {
+    return {
+        siteKey: row.site_key,
+        enabled: row.enabled === 1,
+        currency: row.currency,
+        dailyTokenCap: row.daily_token_cap,
+        dailySpendCapMinor: row.daily_spend_cap_minor,
+        perTxCapMinorOverride: row.per_tx_cap_minor_override,
+        updatedAt: row.updated_at,
+    };
+}
+/** Read the global B-4 master toggle. Off (false) when the row is
+ *  absent — that's the default for every install. The value is
+ *  persisted as JSON-encoded boolean so future shape extensions
+ *  (e.g., enabled-since-when, enabled-by-which-user) can attach
+ *  without a key rename. */
+export function getB4Enabled(db) {
+    const raw = readRuntimeState(db, MANAGED_CHROMIUM_B4_ENABLED_KEY);
+    return raw === true;
+}
+/** Atomic write of the global toggle. The dashboard's enable-modal
+ *  flow flips this to true AFTER the user clicks through the
+ *  experimental-danger acknowledgement. */
+export function setB4Enabled(db, enabled) {
+    writeRuntimeState(db, MANAGED_CHROMIUM_B4_ENABLED_KEY, enabled);
+}
+export function getSiteB4Config(db, siteKey) {
+    const row = db
+        .prepare(`SELECT site_key, enabled, currency, daily_token_cap,
+              daily_spend_cap_minor, per_tx_cap_minor_override, updated_at
+         FROM browser_automation_b4_site_config
+        WHERE site_key = ?`)
+        .get(siteKey);
+    return row ? fromDbRow(row) : null;
+}
+export function listSiteB4Configs(db) {
+    const rows = db
+        .prepare(`SELECT site_key, enabled, currency, daily_token_cap,
+              daily_spend_cap_minor, per_tx_cap_minor_override, updated_at
+         FROM browser_automation_b4_site_config
+        ORDER BY site_key`)
+        .all();
+    return rows.map(fromDbRow);
+}
+/**
+ * INSERT OR REPLACE the per-site row. The route layer validates the
+ * cap shapes (Zod) before calling; the schema's CHECK constraints
+ * are the structural floor.
+ *
+ * The currency field is meaningful — the issuance path refuses any
+ * workflow whose `params.currency` does not equal the configured
+ * currency. Changing the currency mid-config is permitted (the
+ * dashboard surfaces a confirmation when the user does so); the
+ * audit row on `browser_automation_workflows` carries the
+ * `currency_mismatch` cancel reason if a stale in-flight token hits
+ * the new shape.
+ */
+export function upsertSiteB4Config(db, input) {
+    const tokenCap = input.dailyTokenCap ?? B4_DEFAULT_DAILY_TOKEN_CAP;
+    const spendCap = input.dailySpendCapMinor ?? B4_DEFAULT_DAILY_SPEND_CAP_MINOR;
+    const perTxOverride = input.perTxCapMinorOverride === undefined
+        ? null
+        : input.perTxCapMinorOverride;
+    db.prepare(`INSERT INTO browser_automation_b4_site_config
+       (site_key, enabled, currency, daily_token_cap,
+        daily_spend_cap_minor, per_tx_cap_minor_override, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT (site_key) DO UPDATE SET
+       enabled = excluded.enabled,
+       currency = excluded.currency,
+       daily_token_cap = excluded.daily_token_cap,
+       daily_spend_cap_minor = excluded.daily_spend_cap_minor,
+       per_tx_cap_minor_override = excluded.per_tx_cap_minor_override,
+       updated_at = excluded.updated_at`).run(input.siteKey, input.enabled ? 1 : 0, input.currency, tokenCap, spendCap, perTxOverride, input.updatedAt);
+    const row = getSiteB4Config(db, input.siteKey);
+    if (!row) {
+        throw new Error("upsertSiteB4Config: post-upsert lookup missing");
+    }
+    return row;
+}
+/**
+ * Delete the row. Called by the dashboard's "Disable B-4" destructive
+ * flow alongside the global toggle reset. After deletion the site
+ * cannot mint tokens until the user re-enables it.
+ */
+export function deleteSiteB4Config(db, siteKey) {
+    const result = db
+        .prepare(`DELETE FROM browser_automation_b4_site_config
+        WHERE site_key = ?`)
+        .run(siteKey);
+    return result.changes;
+}

package/dist/db/browser-automation-purchase-primary-channels-store.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Browser Automation Purchase Primary Channels — Phase B-4 owner-DM
+ * primary-channel selection.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.8 / §13 step 55.
+ *
+ * The B-4 dashboard surfaces every owner DM channel with a
+ * `primary:boolean` flag. Only primary channels receive the
+ * purchase-confirmation DM. At least one primary channel is required
+ * for B-4 to be enabled (the dashboard enable flow checks via
+ * `countPrimaryChannels()` before flipping the master toggle on).
+ *
+ * The (platform, channel_id) shape mirrors the `owner_channels` table's
+ * primary key — by convention every primary entry here must also exist
+ * in `owner_channels` (the dashboard enforces this; the store does not
+ * cross-check on write to keep the SQL surface small).
+ *
+ * Excluded from the 100% coverage gate — prepared statements only.
+ */
+import type Database from "better-sqlite3";
+export interface PrimaryChannelRow {
+    platform: string;
+    channelId: string;
+    setAt: number;
+}
+export interface SetPrimaryChannelInput {
+    platform: string;
+    channelId: string;
+    setAt: number;
+}
+export declare function setPrimaryChannel(db: Database.Database, input: SetPrimaryChannelInput): PrimaryChannelRow;
+export declare function clearPrimaryChannel(db: Database.Database, platform: string, channelId: string): number;
+export declare function listPrimaryChannels(db: Database.Database): PrimaryChannelRow[];
+export declare function countPrimaryChannels(db: Database.Database): number;
+/** Canonical `<platform>:<channel_id>` formatter — used by every site
+ *  that needs to compare channel refs (token delivery list, inbound
+ *  channel match, dashboard surfaces). Centralised so the separator
+ *  cannot drift across modules. */
+export declare function channelRef(platform: string, channelId: string): string;
+/** Reverse parse — supports the `<platform>:<channel_id>` format. The
+ *  channel_id can contain colons (Slack thread refs do), so we split
+ *  only on the first colon. Returns null on malformed input. */
+export declare function parseChannelRef(ref: string): {
+    platform: string;
+    channelId: string;
+} | null;
+/** True when the ref equals an existing primary row. */
+export declare function isPrimaryChannelRef(db: Database.Database, ref: string): boolean;

package/dist/db/browser-automation-purchase-primary-channels-store.js

@@ -0,0 +1,88 @@
+/**
+ * Browser Automation Purchase Primary Channels — Phase B-4 owner-DM
+ * primary-channel selection.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.8 / §13 step 55.
+ *
+ * The B-4 dashboard surfaces every owner DM channel with a
+ * `primary:boolean` flag. Only primary channels receive the
+ * purchase-confirmation DM. At least one primary channel is required
+ * for B-4 to be enabled (the dashboard enable flow checks via
+ * `countPrimaryChannels()` before flipping the master toggle on).
+ *
+ * The (platform, channel_id) shape mirrors the `owner_channels` table's
+ * primary key — by convention every primary entry here must also exist
+ * in `owner_channels` (the dashboard enforces this; the store does not
+ * cross-check on write to keep the SQL surface small).
+ *
+ * Excluded from the 100% coverage gate — prepared statements only.
+ */
+function fromDbRow(row) {
+    return {
+        platform: row.platform,
+        channelId: row.channel_id,
+        setAt: row.set_at,
+    };
+}
+export function setPrimaryChannel(db, input) {
+    db.prepare(`INSERT OR REPLACE INTO browser_automation_purchase_primary_channels
+       (platform, channel_id, set_at)
+     VALUES (?, ?, ?)`).run(input.platform, input.channelId, input.setAt);
+    return {
+        platform: input.platform,
+        channelId: input.channelId,
+        setAt: input.setAt,
+    };
+}
+export function clearPrimaryChannel(db, platform, channelId) {
+    const result = db
+        .prepare(`DELETE FROM browser_automation_purchase_primary_channels
+        WHERE platform = ? AND channel_id = ?`)
+        .run(platform, channelId);
+    return result.changes;
+}
+export function listPrimaryChannels(db) {
+    const rows = db
+        .prepare(`SELECT platform, channel_id, set_at
+         FROM browser_automation_purchase_primary_channels
+        ORDER BY platform, channel_id`)
+        .all();
+    return rows.map(fromDbRow);
+}
+export function countPrimaryChannels(db) {
+    const row = db
+        .prepare(`SELECT COUNT(*) AS c
+         FROM browser_automation_purchase_primary_channels`)
+        .get();
+    return row?.c ?? 0;
+}
+/** Canonical `<platform>:<channel_id>` formatter — used by every site
+ *  that needs to compare channel refs (token delivery list, inbound
+ *  channel match, dashboard surfaces). Centralised so the separator
+ *  cannot drift across modules. */
+export function channelRef(platform, channelId) {
+    return `${platform}:${channelId}`;
+}
+/** Reverse parse — supports the `<platform>:<channel_id>` format. The
+ *  channel_id can contain colons (Slack thread refs do), so we split
+ *  only on the first colon. Returns null on malformed input. */
+export function parseChannelRef(ref) {
+    if (typeof ref !== "string")
+        return null;
+    const idx = ref.indexOf(":");
+    if (idx <= 0 || idx === ref.length - 1)
+        return null;
+    return { platform: ref.slice(0, idx), channelId: ref.slice(idx + 1) };
+}
+/** True when the ref equals an existing primary row. */
+export function isPrimaryChannelRef(db, ref) {
+    const parsed = parseChannelRef(ref);
+    if (!parsed)
+        return false;
+    const row = db
+        .prepare(`SELECT COUNT(*) AS c
+         FROM browser_automation_purchase_primary_channels
+        WHERE platform = ? AND channel_id = ?`)
+        .get(parsed.platform, parsed.channelId);
+    return (row?.c ?? 0) > 0;
+}

package/dist/db/browser-automation-purchase-replies-store.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Browser Automation Purchase Replies — Phase B-4 audit trail for every
+ * inbound `!~xxxxxxxx`-shaped reply.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.6 / §13 steps 51, 60.
+ *
+ * Each row records:
+ *   - `received_at` — epoch ms
+ *   - `channel_ref` — `<platform>:<channel_id>`
+ *   - `message_body_hash` — sha256 of the raw inbound body (NOT the
+ *     parsed token; gives the dashboard's replay-analysis view a stable
+ *     dedup key without persisting the secret)
+ *   - `matched_jti` — non-null when the lookup found a row, null on
+ *     `shape_invalid` / `no_match`
+ *   - `outcome` — categorical decision the adapter handler emitted
+ *
+ * Row retention: pruned by the daily cleanup cron (§13 step 60) after
+ * 90 days. Older audit rows live in the dashboard's audit-export
+ * surface; this table caps growth.
+ *
+ * Excluded from the 100% coverage gate — prepared statements only; the
+ * decision logic that drives `outcome` lives in `purchase-tokens.ts` and
+ * is the covered surface.
+ */
+import type Database from "better-sqlite3";
+export type PurchaseReplyOutcome = "consumed" | "wrong_channel" | "expired" | "already_consumed" | "already_cancelled" | "no_match" | "cancel_workflow" | "shape_invalid";
+export interface PurchaseReplyRow {
+    id: number;
+    receivedAt: number;
+    channelRef: string;
+    messageBodyHash: string;
+    matchedJti: string | null;
+    outcome: PurchaseReplyOutcome;
+}
+export interface InsertPurchaseReplyInput {
+    receivedAt: number;
+    channelRef: string;
+    messageBodyHash: string;
+    matchedJti: string | null;
+    outcome: PurchaseReplyOutcome;
+}
+export declare function insertPurchaseReply(db: Database.Database, input: InsertPurchaseReplyInput): PurchaseReplyRow;
+export declare function listRecentPurchaseReplies(db: Database.Database, limit?: number): PurchaseReplyRow[];
+/**
+ * Prune audit rows older than `cutoffMs`. Default retention is 90
+ * days; the caller (retention sweep) supplies the precise cutoff.
+ */
+export declare function deletePurchaseRepliesOlderThan(db: Database.Database, cutoffMs: number): number;