co-maintainer 0.4.0-beta.1

package/dist/src/store/replies.js

@@ -0,0 +1,79 @@
+import { getAppDb } from "./app_db.js";
+import { insertJob } from "./jobs.js";
+import { nowIso } from "../util/time.js";
+export function createReplyRequestAndJob(input) {
+    const existing = findReplyRequest(input.repo, input.sourceKind, input.sourceCommentId);
+    if (existing)
+        return { request: existing, created: false };
+    const db = getAppDb();
+    const requestId = crypto.randomUUID();
+    const jobId = crypto.randomUUID();
+    const now = nowIso();
+    const queueKey = `reply:${input.repo}:${input.sourceKind}:${input.sourceCommentId}`;
+    db.exec("BEGIN");
+    try {
+        db.prepare(`INSERT INTO reply_requests
+         (id, repo, pr_number, source_kind, source_comment_id,
+          target_comment_id, source_body, source_author, source_path,
+          source_line, source_commit_id, status, job_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'queued', ?, ?, ?)`).run(requestId, input.repo, input.prNumber, input.sourceKind, input.sourceCommentId, input.targetCommentId ?? null, input.sourceBody, input.sourceAuthor ?? null, input.sourcePath ?? null, input.sourceLine ?? null, input.sourceCommitId ?? null, jobId, now, now);
+        insertJob({
+            id: jobId,
+            type: "reply",
+            repo: input.repo,
+            prNumber: input.prNumber,
+            args: { requestId },
+            deliveryId: input.deliveryId,
+            queueKey,
+        });
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+    return { request: getReplyRequest(requestId), created: true };
+}
+export function getReplyRequest(id) {
+    return getAppDb()
+        .prepare(`SELECT * FROM reply_requests WHERE id = ?`)
+        .get(id);
+}
+export function findReplyRequest(repo, sourceKind, sourceCommentId) {
+    return getAppDb()
+        .prepare(`SELECT * FROM reply_requests
+     WHERE repo = ? AND source_kind = ? AND source_comment_id = ?`)
+        .get(repo, sourceKind, sourceCommentId);
+}
+export function findReplyByPostedComment(repo, prNumber, commentId) {
+    return getAppDb()
+        .prepare(`SELECT * FROM reply_requests
+     WHERE repo = ? AND pr_number = ? AND posted_comment_id = ?
+     ORDER BY created_at DESC LIMIT 1`)
+        .get(repo, prNumber, commentId);
+}
+export function setReplyStatus(id, status, patch = {}) {
+    const attempts = status === "generating" || status === "posting" ? 1 : 0;
+    getAppDb()
+        .prepare(`UPDATE reply_requests SET
+       status = ?,
+       answer_md = COALESCE(?, answer_md),
+       posted_comment_id = COALESCE(?, posted_comment_id),
+       error = COALESCE(?, error),
+       attempts = attempts + ?,
+       updated_at = ?
+     WHERE id = ?`)
+        .run(status, patch.answer_md ?? null, patch.posted_comment_id ?? null, patch.error ?? null, attempts, nowIso(), id);
+}
+export function setReplyJobId(id, jobId) {
+    getAppDb()
+        .prepare(`UPDATE reply_requests SET job_id = ?, updated_at = ? WHERE id = ?`)
+        .run(jobId, nowIso(), id);
+}
+export function listRecoverableReplies() {
+    return getAppDb()
+        .prepare(`SELECT * FROM reply_requests
+     WHERE status IN ('queued', 'generating', 'ready', 'posting')
+     ORDER BY created_at`)
+        .all();
+}

package/dist/src/store/repos.d.ts

@@ -0,0 +1,11 @@
+import type { RepoRow } from "./rows.ts";
+export declare function activateRepo(fullName: string, installationId: number | undefined): void;
+export declare function deactivateRepo(fullName: string): void;
+export declare function deactivateReposForInstallation(installationId: number): void;
+export declare function updateRepoSettings(fullName: string, patch: Partial<Pick<RepoRow, "auto_review" | "review_scope" | "skip_drafts" | "skip_bots" | "use_codegraph">>): void;
+export declare function markKnowledgeBuilt(fullName: string, baseSha: string): void;
+export declare function setInstallationId(fullName: string, installationId: number): void;
+export declare function getRepo(fullName: string): RepoRow | undefined;
+/** Case-insensitive match on `repos.full_name` (plan §14.4). */
+export declare function findRepoByFullName(fullName: string): RepoRow | undefined;
+export declare function listActiveRepos(): RepoRow[];

package/dist/src/store/repos.js

@@ -0,0 +1,59 @@
+import { getAppDb } from "./app_db.js";
+import { deleteDrift } from "./drift.js";
+import { nowIso } from "../util/time.js";
+export function activateRepo(fullName, installationId) {
+    getAppDb()
+        .prepare(`INSERT INTO repos (full_name, installation_id, active, auto_review, created_at)
+     VALUES (?, ?, 1, 1, ?)
+     ON CONFLICT(full_name) DO UPDATE SET
+       installation_id = excluded.installation_id, active = 1`)
+        .run(fullName, installationId ?? null, nowIso());
+}
+export function deactivateRepo(fullName) {
+    getAppDb()
+        .prepare(`UPDATE repos SET active = 0 WHERE full_name = ?`)
+        .run(fullName);
+}
+export function deactivateReposForInstallation(installationId) {
+    getAppDb()
+        .prepare(`UPDATE repos SET active = 0 WHERE installation_id = ?`)
+        .run(installationId);
+}
+export function updateRepoSettings(fullName, patch) {
+    const fields = Object.keys(patch);
+    if (fields.length === 0)
+        return;
+    const set = fields.map((field) => `${field} = ?`).join(", ");
+    getAppDb()
+        .prepare(`UPDATE repos SET ${set} WHERE full_name = ?`)
+        .run(...fields.map((field) => patch[field]), fullName);
+}
+export function markKnowledgeBuilt(fullName, baseSha) {
+    getAppDb()
+        .prepare(`UPDATE repos SET knowledge_built_at = ?, knowledge_base_sha = ? WHERE full_name = ?`)
+        .run(nowIso(), baseSha, fullName);
+    // The stored drift counts how far the repository moved past the previous
+    // baseline, so a rebuild makes them meaningless rather than merely stale.
+    deleteDrift(fullName);
+}
+export function setInstallationId(fullName, installationId) {
+    getAppDb()
+        .prepare(`UPDATE repos SET installation_id = ? WHERE full_name = ?`)
+        .run(installationId, fullName);
+}
+export function getRepo(fullName) {
+    return getAppDb()
+        .prepare(`SELECT * FROM repos WHERE full_name = ?`)
+        .get(fullName);
+}
+/** Case-insensitive match on `repos.full_name` (plan §14.4). */
+export function findRepoByFullName(fullName) {
+    return getAppDb()
+        .prepare(`SELECT * FROM repos WHERE lower(full_name) = lower(?)`)
+        .get(fullName);
+}
+export function listActiveRepos() {
+    return getAppDb()
+        .prepare(`SELECT * FROM repos WHERE active = 1 ORDER BY full_name`)
+        .all();
+}

package/dist/src/store/reviews.d.ts

@@ -0,0 +1,86 @@
+import type { ReviewRow } from "./rows.ts";
+export declare function insertRemoteReview(row: {
+    id: string;
+    subjectId: string;
+    repo: string;
+    branch: string;
+    tokenId: string;
+    tokenName: string;
+    jobId: string;
+    scope: string;
+    model: string;
+}): void;
+export declare function insertReview(row: {
+    id: string;
+    repo: string;
+    prNumber: number;
+    jobId: string;
+    headSha: string;
+    baseSha: string;
+    scope: string;
+    model: string;
+    trigger?: string;
+    round?: number;
+    subjectId?: string;
+    guideBuiltAt?: string | null;
+}): void;
+/** Written immediately before and after the `POST .../reviews` call, with
+ * nothing else run between either write and the call. */
+export declare function setReviewStatus(id: string, status: ReviewRow["status"], patch?: Partial<Pick<ReviewRow, "posted_review_id" | "findings_count" | "tokens_in" | "tokens_out" | "cost" | "duration_ms" | "check_run_id" | "posted_fallback" | "open_count" | "closed_count" | "subject_id" | "guide_built_at">>): void;
+export declare function setReviewScope(id: string, scope: string, baseSha: string): void;
+export declare function getReview(id: string): ReviewRow | undefined;
+export declare function getReviewByJobId(jobId: string): ReviewRow | undefined;
+/** Newest round first. The PR detail page reads this directly. */
+export declare function listReviewsForPr(repo: string, prNumber: number): ReviewRow[];
+export declare function latestPostedReview(repo: string, prNumber: number): ReviewRow | undefined;
+export type ReviewStats = {
+    reviews: number;
+    pullRequests: number;
+    findings: number;
+    cost: number;
+    tokensIn: number;
+    tokensOut: number;
+    failed: number;
+    avgDurationMs: number;
+};
+/** `untilIso` is exclusive, which is what lets the trend row ask for the
+ * window before the one on screen without double counting its edge. */
+export declare function reviewStats(sinceIso: string, repo?: string, untilIso?: string): ReviewStats;
+export declare function reviewStatsByRepo(sinceIso: string): (ReviewStats & {
+    repo: string;
+})[];
+export declare function reviewStatsByDay(sinceIso: string): {
+    day: string;
+    reviews: number;
+    findings: number;
+    cost: number;
+}[];
+export declare function reviewStatsByModel(sinceIso: string): (ReviewStats & {
+    model: string;
+})[];
+export declare function listRecentReviews(limit: number, offset?: number): ReviewRow[];
+export declare function countReviews(): number;
+export type PullSummary = {
+    pr_number: number;
+    last_reviewed: string;
+    findings: number;
+    cost: number;
+    review_count: number;
+};
+export declare function listPullSummaries(repo: string, limit: number, offset: number): {
+    items: PullSummary[];
+    total: number;
+};
+export declare function listRemoteReviewsForRepo(repo: string, limit: number, offset?: number, sinceIso?: string): ReviewRow[];
+export declare function remoteTokenUsageSince(tokenId: string, sinceIso: string): {
+    reviews: number;
+    cost: number;
+};
+export declare function reviewStatsByRemoteToken(sinceIso: string): {
+    tokenId: string;
+    tokenName: string;
+    reviews: number;
+    cost: number;
+    findings: number;
+}[];
+export declare function listLatestReviewsForRepo(repo: string, limit: number): ReviewRow[];

package/dist/src/store/reviews.js

@@ -0,0 +1,220 @@
+import { getAppDb } from "./app_db.js";
+import { nowIso } from "../util/time.js";
+export function insertRemoteReview(row) {
+    getAppDb()
+        .prepare(`INSERT INTO reviews
+       (id, kind, subject_id, repo, pr_number, branch, token_id, token_name,
+        job_id, head_sha, base_sha, scope, model, status, created_at, round)
+     VALUES (?, 'remote', ?, ?, NULL, ?, ?, ?, ?, NULL, NULL, ?, ?, 'queued', ?, 1)`)
+        .run(row.id, row.subjectId, row.repo, row.branch, row.tokenId, row.tokenName, row.jobId, row.scope, row.model, nowIso());
+}
+export function insertReview(row) {
+    getAppDb()
+        .prepare(`INSERT INTO reviews
+       (id, kind, subject_id, repo, pr_number, job_id, head_sha, base_sha, scope, model,
+        status, created_at, round, "trigger", guide_built_at)
+     VALUES (?, 'pr', ?, ?, ?, ?, ?, ?, ?, ?, 'drafting', ?, ?, ?, ?)`)
+        .run(row.id, row.subjectId ?? null, row.repo, row.prNumber, row.jobId, row.headSha, row.baseSha, row.scope, row.model, nowIso(), row.round ?? 1, row.trigger ?? null, row.guideBuiltAt ?? null);
+}
+/** Written immediately before and after the `POST .../reviews` call, with
+ * nothing else run between either write and the call. */
+export function setReviewStatus(id, status, patch = {}) {
+    getAppDb()
+        .prepare(`UPDATE reviews SET status = ?,
+       posted_review_id = COALESCE(?, posted_review_id),
+       findings_count = COALESCE(?, findings_count),
+       open_count = COALESCE(?, open_count),
+       closed_count = COALESCE(?, closed_count),
+       tokens_in = COALESCE(?, tokens_in),
+       tokens_out = COALESCE(?, tokens_out),
+       cost = COALESCE(?, cost),
+       duration_ms = COALESCE(?, duration_ms),
+       check_run_id = COALESCE(?, check_run_id),
+       posted_fallback = COALESCE(?, posted_fallback),
+       subject_id = COALESCE(?, subject_id),
+       guide_built_at = COALESCE(?, guide_built_at)
+     WHERE id = ?`)
+        .run(status, patch.posted_review_id ?? null, patch.findings_count ?? null, patch.open_count ?? null, patch.closed_count ?? null, patch.tokens_in ?? null, patch.tokens_out ?? null, patch.cost ?? null, patch.duration_ms ?? null, patch.check_run_id ?? null, patch.posted_fallback ?? null, patch.subject_id ?? null, patch.guide_built_at ?? null, id);
+}
+export function setReviewScope(id, scope, baseSha) {
+    getAppDb()
+        .prepare(`UPDATE reviews SET scope = ?, base_sha = ? WHERE id = ?`)
+        .run(scope, baseSha, id);
+}
+export function getReview(id) {
+    return getAppDb()
+        .prepare(`SELECT * FROM reviews WHERE id = ?`)
+        .get(id);
+}
+export function getReviewByJobId(jobId) {
+    return getAppDb()
+        .prepare(`SELECT * FROM reviews WHERE job_id = ? ORDER BY created_at DESC LIMIT 1`)
+        .get(jobId);
+}
+/** Newest round first. The PR detail page reads this directly. */
+export function listReviewsForPr(repo, prNumber) {
+    return getAppDb()
+        .prepare(`SELECT * FROM reviews WHERE repo = ? AND pr_number = ? ORDER BY round DESC, created_at DESC`)
+        .all(repo, prNumber);
+}
+export function latestPostedReview(repo, prNumber) {
+    return getAppDb()
+        .prepare(`SELECT * FROM reviews
+     WHERE repo = ? AND pr_number = ? AND status = 'posted'
+     ORDER BY round DESC, created_at DESC LIMIT 1`)
+        .get(repo, prNumber);
+}
+/** Every aggregate the dashboard reads comes from this one column list, so a
+ * new figure lands on the totals, the per repo table and the trend window at
+ * the same time. */
+const STATS_COLUMNS = `COUNT(*) AS reviews,
+      COUNT(DISTINCT pr_number) AS pullRequests,
+      COALESCE(SUM(findings_count), 0) AS findings,
+      COALESCE(SUM(cost), 0) AS cost,
+      COALESCE(SUM(tokens_in), 0) AS tokensIn,
+      COALESCE(SUM(tokens_out), 0) AS tokensOut,
+      COALESCE(SUM(status = 'failed'), 0) AS failed,
+      COALESCE(AVG(duration_ms), 0) AS avgDurationMs`;
+function asStats(row) {
+    return {
+        reviews: Number(row?.reviews ?? 0),
+        pullRequests: Number(row?.pullRequests ?? 0),
+        findings: Number(row?.findings ?? 0),
+        cost: Number(row?.cost ?? 0),
+        tokensIn: Number(row?.tokensIn ?? 0),
+        tokensOut: Number(row?.tokensOut ?? 0),
+        failed: Number(row?.failed ?? 0),
+        avgDurationMs: Number(row?.avgDurationMs ?? 0),
+    };
+}
+/** `untilIso` is exclusive, which is what lets the trend row ask for the
+ * window before the one on screen without double counting its edge. */
+export function reviewStats(sinceIso, repo, untilIso) {
+    const where = ["created_at >= ?", "kind = 'pr'"];
+    const params = [sinceIso];
+    if (untilIso) {
+        where.push("created_at < ?");
+        params.push(untilIso);
+    }
+    if (repo) {
+        where.push("repo = ?");
+        params.push(repo);
+    }
+    return asStats(getAppDb()
+        .prepare(`SELECT ${STATS_COLUMNS} FROM reviews WHERE ${where.join(" AND ")}`)
+        .get(...params));
+}
+export function reviewStatsByRepo(sinceIso) {
+    return getAppDb()
+        .prepare(`SELECT repo, ${STATS_COLUMNS}
+     FROM reviews WHERE created_at >= ?
+     GROUP BY repo
+     ORDER BY cost DESC`)
+        .all(sinceIso)
+        .map((row) => ({ ...asStats(row), repo: row.repo }));
+}
+export function reviewStatsByDay(sinceIso) {
+    return getAppDb()
+        .prepare(`SELECT substr(created_at, 1, 10) AS day,
+        COUNT(*) AS reviews,
+        COALESCE(SUM(findings_count), 0) AS findings,
+        COALESCE(SUM(cost), 0) AS cost
+     FROM reviews WHERE created_at >= ?
+     GROUP BY day
+     ORDER BY day`)
+        .all(sinceIso);
+}
+export function reviewStatsByModel(sinceIso) {
+    return getAppDb()
+        .prepare(`SELECT model, ${STATS_COLUMNS}
+     FROM reviews WHERE created_at >= ?
+     GROUP BY model
+     ORDER BY cost DESC`)
+        .all(sinceIso)
+        .map((row) => ({ ...asStats(row), model: row.model }));
+}
+export function listRecentReviews(limit, offset = 0) {
+    return getAppDb()
+        .prepare(`SELECT * FROM reviews ORDER BY created_at DESC LIMIT ? OFFSET ?`)
+        .all(limit, offset);
+}
+export function countReviews() {
+    return Number(getAppDb().prepare(`SELECT COUNT(*) AS n FROM reviews`).get()
+        ?.n ?? 0);
+}
+export function listPullSummaries(repo, limit, offset) {
+    const total = Number(getAppDb()
+        .prepare(`SELECT COUNT(DISTINCT pr_number) AS n FROM reviews WHERE repo = ?`)
+        .get(repo)?.n ?? 0);
+    const items = getAppDb()
+        .prepare(`SELECT pr_number,
+        MAX(created_at) AS last_reviewed,
+        COALESCE(SUM(findings_count), 0) AS findings,
+        COALESCE(SUM(cost), 0) AS cost,
+        COUNT(*) AS review_count
+     FROM reviews WHERE repo = ?
+     GROUP BY pr_number
+     ORDER BY last_reviewed DESC
+     LIMIT ? OFFSET ?`)
+        .all(repo, limit, offset);
+    return { items, total };
+}
+export function listRemoteReviewsForRepo(repo, limit, offset = 0, sinceIso) {
+    if (sinceIso) {
+        return getAppDb()
+            .prepare(`SELECT * FROM reviews
+       WHERE repo = ? AND kind = 'remote' AND created_at >= ?
+       ORDER BY created_at DESC
+       LIMIT ? OFFSET ?`)
+            .all(repo, sinceIso, limit, offset);
+    }
+    return getAppDb()
+        .prepare(`SELECT * FROM reviews
+     WHERE repo = ? AND kind = 'remote'
+     ORDER BY created_at DESC
+     LIMIT ? OFFSET ?`)
+        .all(repo, limit, offset);
+}
+export function remoteTokenUsageSince(tokenId, sinceIso) {
+    const row = getAppDb()
+        .prepare(`SELECT COUNT(*) AS reviews, COALESCE(SUM(cost), 0) AS cost
+     FROM reviews
+     WHERE token_id = ? AND kind = 'remote' AND created_at >= ?`)
+        .get(tokenId, sinceIso);
+    return {
+        reviews: Number(row?.reviews ?? 0),
+        cost: Number(row?.cost ?? 0),
+    };
+}
+export function reviewStatsByRemoteToken(sinceIso) {
+    return getAppDb()
+        .prepare(`SELECT token_id, token_name,
+            COUNT(*) AS reviews,
+            COALESCE(SUM(cost), 0) AS cost,
+            COALESCE(SUM(findings_count), 0) AS findings
+     FROM reviews
+     WHERE kind = 'remote' AND created_at >= ? AND token_id IS NOT NULL
+     GROUP BY token_id, token_name
+     ORDER BY cost DESC`)
+        .all(sinceIso)
+        .map((row) => ({
+        tokenId: row.token_id,
+        tokenName: row.token_name,
+        reviews: Number(row.reviews),
+        cost: Number(row.cost),
+        findings: Number(row.findings),
+    }));
+}
+export function listLatestReviewsForRepo(repo, limit) {
+    return getAppDb()
+        .prepare(`SELECT r.* FROM reviews r
+     INNER JOIN (
+       SELECT pr_number, MAX(created_at) AS t
+       FROM reviews WHERE repo = ?
+       GROUP BY pr_number
+     ) latest
+       ON r.repo = ? AND r.pr_number = latest.pr_number AND r.created_at = latest.t
+     ORDER BY r.created_at DESC
+     LIMIT ?`)
+        .all(repo, repo, limit);
+}

package/dist/src/store/rows.d.ts

@@ -0,0 +1,179 @@
+/** JSON columns (permissions, events, args, settings) are stored as their
+ * raw text; the table module that owns each one decides whether callers
+ * see the string or a parsed object. */
+export type InstallationRow = {
+    id: number;
+    account_login: string;
+    account_type: string;
+    permissions: string;
+    events: string;
+    created_at: string;
+    suspended_at: string | null;
+    removed_at: string | null;
+};
+export type RepoRow = {
+    full_name: string;
+    installation_id: number | null;
+    active: number;
+    auto_review: number;
+    review_scope: string;
+    skip_drafts: number;
+    skip_bots: number;
+    knowledge_built_at: string | null;
+    knowledge_base_sha: string | null;
+    settings: string;
+    created_at: string;
+    use_codegraph: number;
+};
+export type JobRow = {
+    id: string;
+    type: string;
+    repo: string;
+    pr_number: number | null;
+    status: string;
+    args: string;
+    delivery_id: string | null;
+    queue_key: string | null;
+    attempt: number;
+    created_at: string;
+    started_at: string | null;
+    finished_at: string | null;
+    error: string | null;
+    superseded_by: string | null;
+    cancel_reason: string | null;
+};
+export type JobLogRow = {
+    job_id: string;
+    seq: number;
+    at: string;
+    level: string;
+    message: string;
+};
+export type ReviewRow = {
+    id: string;
+    kind: string;
+    subject_id: string | null;
+    repo: string;
+    pr_number: number | null;
+    branch: string | null;
+    token_id: string | null;
+    token_name: string | null;
+    job_id: string;
+    head_sha: string | null;
+    base_sha: string | null;
+    scope: string;
+    model: string;
+    findings_count: number;
+    open_count: number;
+    closed_count: number;
+    tokens_in: number;
+    tokens_out: number;
+    cost: number | null;
+    duration_ms: number | null;
+    posted_review_id: string | null;
+    status: string;
+    created_at: string;
+    round: number;
+    trigger: string | null;
+    check_run_id: string | null;
+    posted_fallback: number;
+    guide_built_at: string | null;
+    codegraph: string | null;
+};
+export type FindingRow = {
+    id: string;
+    review_id: string;
+    severity: string;
+    path: string | null;
+    line_from: number | null;
+    line_to: number | null;
+    title: string;
+    body_md: string;
+    posted_comment_id: string | null;
+    thread_comment_id: string | null;
+    first_seen_review_id: string | null;
+    anchor_text: string | null;
+    state: string;
+    carried_from_finding_id: string | null;
+    close_reason: string | null;
+};
+export type SubjectRow = {
+    id: string;
+    kind: string;
+    repo: string;
+    pr_number: number | null;
+    branch: string | null;
+    token_id: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export type SubjectRevisionRow = {
+    subject_id: string;
+    review_id: string;
+    files_json: string;
+    visible_paths_json: string;
+    guide_built_at: string | null;
+    created_at: string;
+};
+export type ReplyRequestRow = {
+    id: string;
+    repo: string;
+    pr_number: number;
+    source_kind: string;
+    source_comment_id: string;
+    target_comment_id: string | null;
+    source_body: string;
+    source_author: string | null;
+    source_path: string | null;
+    source_line: number | null;
+    source_commit_id: string | null;
+    status: string;
+    answer_md: string | null;
+    posted_comment_id: string | null;
+    job_id: string | null;
+    error: string | null;
+    attempts: number;
+    created_at: string;
+    updated_at: string;
+};
+export type DeliveryRow = {
+    delivery_id: string;
+    event: string;
+    action: string | null;
+    repo: string | null;
+    pr_number: number | null;
+    received_at: string;
+    outcome: string;
+    reason: string | null;
+};
+export type SessionRow = {
+    token_hash: string;
+    username: string;
+    created_at: string;
+    expires_at: string;
+    last_seen_at: string;
+};
+export type DriftRow = {
+    repo: string;
+    as_of: string;
+    prs_since: number;
+    prs_updated: number;
+    commits_since: number;
+    files_changed: number;
+};
+export type RemoteTokenRow = {
+    id: string;
+    name: string;
+    token_hash: string;
+    active: number;
+    created_at: string;
+    last_used_at: string | null;
+};
+export type RemoteReviewInputRow = {
+    job_id: string;
+    revision_json: string;
+    capabilities_json: string;
+    request_id: string;
+    token_id: string;
+    created_at: string;
+};

package/dist/src/store/rows.js

@@ -0,0 +1,4 @@
+/** JSON columns (permissions, events, args, settings) are stored as their
+ * raw text; the table module that owns each one decides whether callers
+ * see the string or a parsed object. */
+export {};

package/dist/src/store/sessions.d.ts

@@ -0,0 +1,8 @@
+import type { SessionRow } from "./rows.ts";
+export declare function insertSession(tokenHash: string, username: string, expiresAt: string): void;
+/** Returns the session only if it exists and has not expired, touching
+ * `last_seen_at` on the way — an expired row is left for
+ * `deleteExpiredSessions` to reap rather than deleted here. */
+export declare function getSession(tokenHash: string): SessionRow | undefined;
+export declare function deleteSession(tokenHash: string): void;
+export declare function deleteExpiredSessions(): void;

package/dist/src/store/sessions.js

@@ -0,0 +1,34 @@
+/** Stores only the token's hash, never the raw token — hashing itself is
+ * `server/auth.ts`'s concern, not this module's. */
+import { getAppDb } from "./app_db.js";
+import { nowIso } from "../util/time.js";
+export function insertSession(tokenHash, username, expiresAt) {
+    const now = nowIso();
+    getAppDb()
+        .prepare(`INSERT INTO sessions (token_hash, username, created_at, expires_at, last_seen_at)
+     VALUES (?, ?, ?, ?, ?)`)
+        .run(tokenHash, username, now, expiresAt, now);
+}
+/** Returns the session only if it exists and has not expired, touching
+ * `last_seen_at` on the way — an expired row is left for
+ * `deleteExpiredSessions` to reap rather than deleted here. */
+export function getSession(tokenHash) {
+    const db = getAppDb();
+    const row = db
+        .prepare(`SELECT * FROM sessions WHERE token_hash = ?`)
+        .get(tokenHash);
+    if (!row || row.expires_at <= nowIso())
+        return undefined;
+    db.prepare(`UPDATE sessions SET last_seen_at = ? WHERE token_hash = ?`).run(nowIso(), tokenHash);
+    return row;
+}
+export function deleteSession(tokenHash) {
+    getAppDb()
+        .prepare(`DELETE FROM sessions WHERE token_hash = ?`)
+        .run(tokenHash);
+}
+export function deleteExpiredSessions() {
+    getAppDb()
+        .prepare(`DELETE FROM sessions WHERE expires_at <= ?`)
+        .run(nowIso());
+}

package/dist/src/store/skill_state.d.ts

@@ -0,0 +1,3 @@
+import type { State } from "../knowledge/types.ts";
+export declare function readState(repo: string): Promise<State | undefined>;
+export declare function writeState(state: State): Promise<void>;