@spinabot/brigade 1.0.1 → 1.0.2

package/convex/cron.d.ts

@@ -0,0 +1,237 @@
+export declare const listJobs: import("convex/server").RegisteredQuery<"public", {
+    enabledOnly?: boolean | undefined;
+    ownerUserId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"cronJobs">;
+    _creationTime: number;
+    agentId?: string | undefined;
+    description?: string | undefined;
+    sessionKey?: string | undefined;
+    wakeMode?: string | undefined;
+    delivery?: ArrayBuffer | undefined;
+    failureAlert?: any;
+    deleteAfterRun?: boolean | undefined;
+    createdByChannelId?: string | undefined;
+    createdByConversationId?: string | undefined;
+    createdByAccountId?: string | undefined;
+    scheduleExpr?: string | undefined;
+    scheduleTz?: string | undefined;
+    scheduleStaggerMs?: number | undefined;
+    scheduleEveryMs?: number | undefined;
+    scheduleAnchorMs?: number | undefined;
+    scheduleAt?: number | undefined;
+    stateNextRunAtMs?: number | undefined;
+    stateLastRunAtMs?: number | undefined;
+    stateRunningAtMs?: number | undefined;
+    stateLastStatus?: string | undefined;
+    stateLastError?: string | undefined;
+    stateScheduleErrorCount?: number | undefined;
+    stateConsecutiveErrorCount?: number | undefined;
+    stateLastFailureAlertAtMs?: number | undefined;
+    stateLastDelivered?: boolean | undefined;
+    stateLastDeliveryStatus?: string | undefined;
+    stateLastDeliveryError?: string | undefined;
+    name: string;
+    enabled: boolean;
+    sessionTarget: string;
+    payload: ArrayBuffer;
+    jobId: string;
+    updatedAtMs: number;
+    createdByKind: "owner" | "channel" | "legacy";
+    ownerUserId: string;
+    scheduleKind: "at" | "every" | "cron";
+    createdAtMs: number;
+}[]>>;
+export declare const getJob: import("convex/server").RegisteredQuery<"public", {
+    jobId: string;
+    ownerUserId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"cronJobs">;
+    _creationTime: number;
+    agentId?: string | undefined;
+    description?: string | undefined;
+    sessionKey?: string | undefined;
+    wakeMode?: string | undefined;
+    delivery?: ArrayBuffer | undefined;
+    failureAlert?: any;
+    deleteAfterRun?: boolean | undefined;
+    createdByChannelId?: string | undefined;
+    createdByConversationId?: string | undefined;
+    createdByAccountId?: string | undefined;
+    scheduleExpr?: string | undefined;
+    scheduleTz?: string | undefined;
+    scheduleStaggerMs?: number | undefined;
+    scheduleEveryMs?: number | undefined;
+    scheduleAnchorMs?: number | undefined;
+    scheduleAt?: number | undefined;
+    stateNextRunAtMs?: number | undefined;
+    stateLastRunAtMs?: number | undefined;
+    stateRunningAtMs?: number | undefined;
+    stateLastStatus?: string | undefined;
+    stateLastError?: string | undefined;
+    stateScheduleErrorCount?: number | undefined;
+    stateConsecutiveErrorCount?: number | undefined;
+    stateLastFailureAlertAtMs?: number | undefined;
+    stateLastDelivered?: boolean | undefined;
+    stateLastDeliveryStatus?: string | undefined;
+    stateLastDeliveryError?: string | undefined;
+    name: string;
+    enabled: boolean;
+    sessionTarget: string;
+    payload: ArrayBuffer;
+    jobId: string;
+    updatedAtMs: number;
+    createdByKind: "owner" | "channel" | "legacy";
+    ownerUserId: string;
+    scheduleKind: "at" | "every" | "cron";
+    createdAtMs: number;
+} | null>>;
+export declare const insertJob: import("convex/server").RegisteredMutation<"public", {
+    agentId?: string | undefined;
+    description?: string | undefined;
+    sessionKey?: string | undefined;
+    wakeMode?: string | undefined;
+    delivery?: ArrayBuffer | undefined;
+    failureAlert?: any;
+    deleteAfterRun?: boolean | undefined;
+    updatedAtMs?: number | undefined;
+    createdByChannelId?: string | undefined;
+    createdByConversationId?: string | undefined;
+    createdByAccountId?: string | undefined;
+    scheduleExpr?: string | undefined;
+    scheduleTz?: string | undefined;
+    scheduleStaggerMs?: number | undefined;
+    scheduleEveryMs?: number | undefined;
+    scheduleAnchorMs?: number | undefined;
+    scheduleAt?: number | undefined;
+    createdAtMs?: number | undefined;
+    stateNextRunAtMs?: number | undefined;
+    stateLastRunAtMs?: number | undefined;
+    stateRunningAtMs?: number | undefined;
+    stateLastStatus?: string | undefined;
+    stateLastError?: string | undefined;
+    stateScheduleErrorCount?: number | undefined;
+    stateConsecutiveErrorCount?: number | undefined;
+    stateLastFailureAlertAtMs?: number | undefined;
+    stateLastDelivered?: boolean | undefined;
+    stateLastDeliveryStatus?: string | undefined;
+    stateLastDeliveryError?: string | undefined;
+    name: string;
+    enabled: boolean;
+    sessionTarget: string;
+    payload: ArrayBuffer;
+    jobId: string;
+    createdByKind: "owner" | "channel" | "legacy";
+    ownerUserId: string;
+    scheduleKind: "at" | "every" | "cron";
+}, Promise<void>>;
+export declare const patchJob: import("convex/server").RegisteredMutation<"public", {
+    unset?: string[] | undefined;
+    jobId: string;
+    ownerUserId: string;
+    patch: any;
+}, Promise<{
+    _id: import("convex/values").GenericId<"cronJobs">;
+    _creationTime: number;
+    agentId?: string | undefined;
+    description?: string | undefined;
+    sessionKey?: string | undefined;
+    wakeMode?: string | undefined;
+    delivery?: ArrayBuffer | undefined;
+    failureAlert?: any;
+    deleteAfterRun?: boolean | undefined;
+    createdByChannelId?: string | undefined;
+    createdByConversationId?: string | undefined;
+    createdByAccountId?: string | undefined;
+    scheduleExpr?: string | undefined;
+    scheduleTz?: string | undefined;
+    scheduleStaggerMs?: number | undefined;
+    scheduleEveryMs?: number | undefined;
+    scheduleAnchorMs?: number | undefined;
+    scheduleAt?: number | undefined;
+    stateNextRunAtMs?: number | undefined;
+    stateLastRunAtMs?: number | undefined;
+    stateRunningAtMs?: number | undefined;
+    stateLastStatus?: string | undefined;
+    stateLastError?: string | undefined;
+    stateScheduleErrorCount?: number | undefined;
+    stateConsecutiveErrorCount?: number | undefined;
+    stateLastFailureAlertAtMs?: number | undefined;
+    stateLastDelivered?: boolean | undefined;
+    stateLastDeliveryStatus?: string | undefined;
+    stateLastDeliveryError?: string | undefined;
+    name: string;
+    enabled: boolean;
+    sessionTarget: string;
+    payload: ArrayBuffer;
+    jobId: string;
+    updatedAtMs: number;
+    createdByKind: "owner" | "channel" | "legacy";
+    ownerUserId: string;
+    scheduleKind: "at" | "every" | "cron";
+    createdAtMs: number;
+} | null>>;
+export declare const deleteJob: import("convex/server").RegisteredMutation<"public", {
+    jobId: string;
+    ownerUserId: string;
+}, Promise<boolean>>;
+export declare const markRunning: import("convex/server").RegisteredMutation<"public", {
+    jobId: string;
+    ownerUserId: string;
+    runningAtMs: number;
+}, Promise<boolean>>;
+export declare const appendRunLog: import("convex/server").RegisteredMutation<"public", {
+    error?: string | undefined;
+    provider?: string | undefined;
+    delivered?: boolean | undefined;
+    sessionKey?: string | undefined;
+    nextRunAtMs?: number | undefined;
+    model?: string | undefined;
+    sessionId?: string | undefined;
+    runAtMs?: number | undefined;
+    summary?: ArrayBuffer | undefined;
+    durationMs?: number | undefined;
+    deliveryStatus?: string | undefined;
+    deliveryError?: string | undefined;
+    usageInput?: number | undefined;
+    usageOutput?: number | undefined;
+    usageCacheRead?: number | undefined;
+    usageCacheWrite?: number | undefined;
+    usageTotalTokens?: number | undefined;
+    usageCostUsd?: number | undefined;
+    jobId: string;
+    status: "error" | "ok" | "skipped";
+    ts: number;
+    ownerUserId: string;
+}, Promise<void>>;
+export declare const listRunLog: import("convex/server").RegisteredQuery<"public", {
+    limit?: number | undefined;
+    jobId: string;
+    ownerUserId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"cronRuns">;
+    _creationTime: number;
+    error?: string | undefined;
+    provider?: string | undefined;
+    delivered?: boolean | undefined;
+    sessionKey?: string | undefined;
+    nextRunAtMs?: number | undefined;
+    model?: string | undefined;
+    sessionId?: string | undefined;
+    runAtMs?: number | undefined;
+    summary?: ArrayBuffer | undefined;
+    durationMs?: number | undefined;
+    deliveryStatus?: string | undefined;
+    deliveryError?: string | undefined;
+    usageInput?: number | undefined;
+    usageOutput?: number | undefined;
+    usageCacheRead?: number | undefined;
+    usageCacheWrite?: number | undefined;
+    usageTotalTokens?: number | undefined;
+    usageCostUsd?: number | undefined;
+    jobId: string;
+    status: "error" | "ok" | "skipped";
+    ts: number;
+    ownerUserId: string;
+}[]>>;
+//# sourceMappingURL=cron.d.ts.map

package/convex/cron.ts

@@ -0,0 +1,199 @@
+// convex/cron.ts — cronJobs + cronRuns + cronServiceState
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+const ScheduleKind = v.union(v.literal("cron"), v.literal("every"), v.literal("at"));
+const RunStatus = v.union(v.literal("ok"), v.literal("error"), v.literal("skipped"));
+const CreatedByKind = v.union(v.literal("owner"), v.literal("channel"), v.literal("legacy"));
+
+export const listJobs = query({
+	args: { ownerUserId: v.string(), enabledOnly: v.optional(v.boolean()) },
+	handler: async (ctx, args) => {
+		if (args.enabledOnly) {
+			return ctx.db
+				.query("cronJobs")
+				.withIndex("by_owner_enabled_next", (q) =>
+					q.eq("ownerUserId", args.ownerUserId).eq("enabled", true),
+				)
+				.collect();
+		}
+		return ctx.db
+			.query("cronJobs")
+			.withIndex("by_owner_job", (q) => q.eq("ownerUserId", args.ownerUserId))
+			.collect();
+	},
+});
+
+export const getJob = query({
+	args: { ownerUserId: v.string(), jobId: v.string() },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("cronJobs")
+			.withIndex("by_owner_job", (q) =>
+				q.eq("ownerUserId", args.ownerUserId).eq("jobId", args.jobId),
+			)
+			.first();
+	},
+});
+
+export const insertJob = mutation({
+	args: {
+		jobId: v.string(),
+		ownerUserId: v.string(),
+		name: v.string(),
+		description: v.optional(v.string()),
+		enabled: v.boolean(),
+		agentId: v.optional(v.string()),
+		sessionKey: v.optional(v.string()),
+		scheduleKind: ScheduleKind,
+		scheduleExpr: v.optional(v.string()),
+		scheduleTz: v.optional(v.string()),
+		scheduleStaggerMs: v.optional(v.number()),
+		scheduleEveryMs: v.optional(v.number()),
+		scheduleAnchorMs: v.optional(v.number()),
+		scheduleAt: v.optional(v.number()),
+		sessionTarget: v.string(),
+		wakeMode: v.optional(v.string()),
+		payload: v.bytes(),
+		delivery: v.optional(v.bytes()),
+		failureAlert: v.optional(v.any()),
+		deleteAfterRun: v.optional(v.boolean()),
+		createdByKind: CreatedByKind,
+		createdByChannelId: v.optional(v.string()),
+		createdByConversationId: v.optional(v.string()),
+		createdByAccountId: v.optional(v.string()),
+		// Honour client timestamps so a filesystem→convex migration preserves
+		// the original create/update times; default to now for fresh jobs.
+		createdAtMs: v.optional(v.number()),
+		updatedAtMs: v.optional(v.number()),
+		// Run-time state — carried through on migration so failure counts +
+		// last-fire bookkeeping survive the move.
+		stateNextRunAtMs: v.optional(v.number()),
+		stateLastRunAtMs: v.optional(v.number()),
+		stateRunningAtMs: v.optional(v.number()),
+		stateLastStatus: v.optional(v.string()),
+		stateLastError: v.optional(v.string()),
+		stateScheduleErrorCount: v.optional(v.number()),
+		stateConsecutiveErrorCount: v.optional(v.number()),
+		stateLastFailureAlertAtMs: v.optional(v.number()),
+		stateLastDelivered: v.optional(v.boolean()),
+		stateLastDeliveryStatus: v.optional(v.string()),
+		stateLastDeliveryError: v.optional(v.string()),
+	},
+	handler: async (ctx, args) => {
+		const now = Date.now();
+		const { createdAtMs, updatedAtMs, ...rest } = args;
+		await ctx.db.insert("cronJobs", {
+			...rest,
+			createdAtMs: createdAtMs ?? now,
+			updatedAtMs: updatedAtMs ?? now,
+		});
+	},
+});
+
+export const patchJob = mutation({
+	args: {
+		ownerUserId: v.string(),
+		jobId: v.string(),
+		patch: v.any(),
+		// Column names to DELETE. Convex's arg serialiser strips
+		// `undefined`-valued object fields before they reach the handler, so a
+		// column can't be cleared from the client by patching it to undefined.
+		// We re-introduce the undefined HERE (server-side) where `db.patch`
+		// honours it as a field deletion.
+		unset: v.optional(v.array(v.string())),
+	},
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("cronJobs")
+			.withIndex("by_owner_job", (q) =>
+				q.eq("ownerUserId", args.ownerUserId).eq("jobId", args.jobId),
+			)
+			.first();
+		if (!existing) throw new Error(`cron: job ${args.jobId} not found`);
+		const patchObj: Record<string, unknown> = {
+			...(args.patch as Record<string, unknown>),
+			updatedAtMs: Date.now(),
+		};
+		if (args.unset) {
+			for (const col of args.unset) patchObj[col] = undefined;
+		}
+		await ctx.db.patch(existing._id, patchObj);
+		return await ctx.db.get(existing._id);
+	},
+});
+
+export const deleteJob = mutation({
+	args: { ownerUserId: v.string(), jobId: v.string() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("cronJobs")
+			.withIndex("by_owner_job", (q) =>
+				q.eq("ownerUserId", args.ownerUserId).eq("jobId", args.jobId),
+			)
+			.first();
+		if (!existing) return false;
+		await ctx.db.delete(existing._id);
+		return true;
+	},
+});
+
+export const markRunning = mutation({
+	args: { ownerUserId: v.string(), jobId: v.string(), runningAtMs: v.number() },
+	handler: async (ctx, args) => {
+		const job = await ctx.db
+			.query("cronJobs")
+			.withIndex("by_owner_job", (q) =>
+				q.eq("ownerUserId", args.ownerUserId).eq("jobId", args.jobId),
+			)
+			.first();
+		if (!job) return false;
+		if (job.stateRunningAtMs && job.stateRunningAtMs > 0) return false;
+		await ctx.db.patch(job._id, { stateRunningAtMs: args.runningAtMs });
+		return true;
+	},
+});
+
+export const appendRunLog = mutation({
+	args: {
+		ownerUserId: v.string(),
+		jobId: v.string(),
+		ts: v.number(),
+		status: RunStatus,
+		error: v.optional(v.string()),
+		summary: v.optional(v.bytes()),
+		delivered: v.optional(v.boolean()),
+		deliveryStatus: v.optional(v.string()),
+		deliveryError: v.optional(v.string()),
+		sessionId: v.optional(v.string()),
+		sessionKey: v.optional(v.string()),
+		runAtMs: v.optional(v.number()),
+		durationMs: v.optional(v.number()),
+		nextRunAtMs: v.optional(v.number()),
+		model: v.optional(v.string()),
+		provider: v.optional(v.string()),
+		usageInput: v.optional(v.number()),
+		usageOutput: v.optional(v.number()),
+		usageCacheRead: v.optional(v.number()),
+		usageCacheWrite: v.optional(v.number()),
+		usageTotalTokens: v.optional(v.number()),
+		usageCostUsd: v.optional(v.number()),
+	},
+	handler: async (ctx, args) => {
+		await ctx.db.insert("cronRuns", args);
+	},
+});
+
+export const listRunLog = query({
+	args: { ownerUserId: v.string(), jobId: v.string(), limit: v.optional(v.number()) },
+	handler: async (ctx, args) => {
+		const limit = args.limit && args.limit > 0 ? args.limit : 50;
+		return ctx.db
+			.query("cronRuns")
+			.withIndex("by_owner_job_ts", (q) =>
+				q.eq("ownerUserId", args.ownerUserId).eq("jobId", args.jobId),
+			)
+			.order("desc")
+			.take(limit);
+	},
+});

package/convex/execApprovals.d.ts

@@ -0,0 +1,31 @@
+export declare const list: import("convex/server").RegisteredQuery<"public", {
+    agentId: string;
+    ownerId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"execApprovals">;
+    _creationTime: number;
+    agentId: string;
+    value: string;
+    kind: "exact" | "pattern";
+    createdAt: number;
+    ownerId: string;
+    valueNormalised: string;
+}[]>>;
+export declare const insert: import("convex/server").RegisteredMutation<"public", {
+    agentId: string;
+    value: string;
+    kind: "exact" | "pattern";
+    ownerId: string;
+    valueNormalised: string;
+}, Promise<{
+    inserted: boolean;
+}>>;
+export declare const remove: import("convex/server").RegisteredMutation<"public", {
+    agentId: string;
+    ownerId: string;
+    valueNormalised: string;
+}, Promise<{
+    removedCommands: number;
+    removedPatterns: number;
+}>>;
+//# sourceMappingURL=execApprovals.d.ts.map

package/convex/execApprovals.ts

@@ -0,0 +1,58 @@
+// convex/execApprovals.ts
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+const Kind = v.union(v.literal("exact"), v.literal("pattern"));
+
+export const list = query({
+	args: { ownerId: v.string(), agentId: v.string() },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("execApprovals")
+			.withIndex("by_owner_agent_kind", (q) =>
+				q.eq("ownerId", args.ownerId).eq("agentId", args.agentId),
+			)
+			.collect();
+	},
+});
+
+export const insert = mutation({
+	args: { ownerId: v.string(), agentId: v.string(), kind: Kind, value: v.string(), valueNormalised: v.string() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("execApprovals")
+			.withIndex("by_owner_agent_value", (q) =>
+				q
+					.eq("ownerId", args.ownerId)
+					.eq("agentId", args.agentId)
+					.eq("valueNormalised", args.valueNormalised),
+			)
+			.first();
+		if (existing) return { inserted: false };
+		await ctx.db.insert("execApprovals", { ...args, createdAt: Date.now() });
+		return { inserted: true };
+	},
+});
+
+export const remove = mutation({
+	args: { ownerId: v.string(), agentId: v.string(), valueNormalised: v.string() },
+	handler: async (ctx, args) => {
+		const rows = await ctx.db
+			.query("execApprovals")
+			.withIndex("by_owner_agent_value", (q) =>
+				q
+					.eq("ownerId", args.ownerId)
+					.eq("agentId", args.agentId)
+					.eq("valueNormalised", args.valueNormalised),
+			)
+			.collect();
+		let removedCommands = 0;
+		let removedPatterns = 0;
+		for (const r of rows) {
+			if (r.kind === "exact") removedCommands += 1;
+			else removedPatterns += 1;
+			await ctx.db.delete(r._id);
+		}
+		return { removedCommands, removedPatterns };
+	},
+});

package/convex/extensions.d.ts

@@ -0,0 +1,30 @@
+export declare const list: import("convex/server").RegisteredQuery<"public", {}, Promise<{
+    _id: import("convex/values").GenericId<"extensions">;
+    _creationTime: number;
+    config?: ArrayBuffer | undefined;
+    bundleBytes?: ArrayBuffer | undefined;
+    manifest?: any;
+    bundleSha?: string | undefined;
+    enabled: boolean;
+    createdBy: string;
+    createdAt: number;
+    origin: "bundled" | "user";
+    updatedAt: number;
+    moduleId: string;
+    sourceLabel: string;
+}[]>>;
+export declare const upsert: import("convex/server").RegisteredMutation<"public", {
+    config?: ArrayBuffer | undefined;
+    bundleBytes?: ArrayBuffer | undefined;
+    manifest?: any;
+    bundleSha?: string | undefined;
+    enabled: boolean;
+    createdBy: string;
+    origin: "bundled" | "user";
+    moduleId: string;
+    sourceLabel: string;
+}, Promise<void>>;
+export declare const remove: import("convex/server").RegisteredMutation<"public", {
+    moduleId: string;
+}, Promise<boolean>>;
+//# sourceMappingURL=extensions.d.ts.map

package/convex/extensions.ts

@@ -0,0 +1,51 @@
+// convex/extensions.ts
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+const Origin = v.union(v.literal("bundled"), v.literal("user"));
+
+export const list = query({
+	args: {},
+	handler: async (ctx) => {
+		return ctx.db.query("extensions").collect();
+	},
+});
+
+export const upsert = mutation({
+	args: {
+		moduleId: v.string(),
+		origin: Origin,
+		bundleBytes: v.optional(v.bytes()),
+		sourceLabel: v.string(),
+		manifest: v.optional(v.any()),
+		enabled: v.boolean(),
+		config: v.optional(v.bytes()),
+		bundleSha: v.optional(v.string()),
+		createdBy: v.string(),
+	},
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("extensions")
+			.withIndex("by_moduleId", (q) => q.eq("moduleId", args.moduleId))
+			.first();
+		const now = Date.now();
+		if (existing) {
+			await ctx.db.replace(existing._id, { ...args, createdAt: existing.createdAt, updatedAt: now });
+		} else {
+			await ctx.db.insert("extensions", { ...args, createdAt: now, updatedAt: now });
+		}
+	},
+});
+
+export const remove = mutation({
+	args: { moduleId: v.string() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("extensions")
+			.withIndex("by_moduleId", (q) => q.eq("moduleId", args.moduleId))
+			.first();
+		if (!existing) return false;
+		await ctx.db.delete(existing._id);
+		return true;
+	},
+});

package/convex/health.d.ts

@@ -0,0 +1,18 @@
+export declare const ping: import("convex/server").RegisteredQuery<"public", {}, Promise<{
+    ok: boolean;
+    schemaVersion: number;
+    hasConfig: boolean;
+    now: number;
+}>>;
+export declare const BUNDLE_VERSION = 7;
+export declare const bundleVersion: import("convex/server").RegisteredQuery<"public", {}, Promise<number>>;
+export declare const getMeta: import("convex/server").RegisteredQuery<"public", {
+    key: string;
+}, Promise<string | null>>;
+export declare const setMeta: import("convex/server").RegisteredMutation<"public", {
+    key: string;
+    value: string;
+}, Promise<{
+    updated: boolean;
+}>>;
+//# sourceMappingURL=health.d.ts.map

package/convex/health.ts

@@ -0,0 +1,69 @@
+// convex/health.ts
+//
+// Convex-side liveness probe. ConvexBrigadeStore.healthcheck() calls this
+// from filesystem-mode boot to confirm the backend is reachable + the
+// schema is deployed. Returns the schema version + the number of seeded
+// brigadeConfig rows so a freshly-deployed-but-empty backend reports
+// distinctly from a populated one.
+
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+export const ping = query({
+	args: {},
+	handler: async (ctx) => {
+		const configRows = await ctx.db.query("brigadeConfig").take(1);
+		return {
+			ok: true,
+			schemaVersion: 2,
+			hasConfig: configRows.length > 0,
+			now: Date.now(),
+		};
+	},
+});
+
+// Brigade function-bundle version. The Node client (verifyConvexBundleVersion
+// in src/storage/boot.ts) requires remote >= its expected constant at every
+// convex boot, so a backend serving an older push fails the boot with ONE
+// clear "run npm run convex:push" error instead of per-domain "Could not
+// find public function" spam (auth/memory/channels hydration failures +
+// per-turn transcript-flush errors). BUMP THIS — and the twin
+// EXPECTED_CONVEX_BUNDLE_VERSION in src/storage/boot.ts — together whenever
+// convex/ functions or the schema change shape.
+export const BUNDLE_VERSION = 7;
+
+export const bundleVersion = query({
+	args: {},
+	handler: async () => BUNDLE_VERSION,
+});
+
+// ============================================================================
+// systemMeta — small singleton facts (encryption-key fingerprint, markers)
+// ============================================================================
+
+export const getMeta = query({
+	args: { key: v.string() },
+	handler: async (ctx, args) => {
+		const row = await ctx.db
+			.query("systemMeta")
+			.withIndex("by_key", (q) => q.eq("key", args.key))
+			.first();
+		return row?.value ?? null;
+	},
+});
+
+export const setMeta = mutation({
+	args: { key: v.string(), value: v.string() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("systemMeta")
+			.withIndex("by_key", (q) => q.eq("key", args.key))
+			.first();
+		if (existing) {
+			await ctx.db.replace(existing._id, { ...args, updatedAt: Date.now() });
+			return { updated: true };
+		}
+		await ctx.db.insert("systemMeta", { ...args, updatedAt: Date.now() });
+		return { updated: false };
+	},
+});