@spinabot/brigade 1.0.1 → 1.1.0

package/convex/sessions.d.ts

@@ -0,0 +1,100 @@
+export declare const getEntry: import("convex/server").RegisteredQuery<"public", {
+    agentId: string;
+    sessionKey: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"sessions">;
+    _creationTime: number;
+    modelId?: string | undefined;
+    provider?: string | undefined;
+    authProfile?: string | undefined;
+    thinkingLevel?: string | undefined;
+    subagent?: {
+        parentRunId?: string | undefined;
+        spawnedWorkspaceDir?: string | undefined;
+        label?: string | undefined;
+        cleanup?: "delete" | "keep" | undefined;
+        spawnDepth: number;
+        spawnedBy: string;
+        spawnedAt: string;
+    } | undefined;
+    extra?: ArrayBuffer | undefined;
+    agentId: string;
+    sessionKey: string;
+    sessionId: string;
+    createdAt: number;
+    lastUsedAt: number;
+} | null>>;
+export declare const listEntries: import("convex/server").RegisteredQuery<"public", {
+    subagentOnly?: boolean | undefined;
+    agentId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"sessions">;
+    _creationTime: number;
+    modelId?: string | undefined;
+    provider?: string | undefined;
+    authProfile?: string | undefined;
+    thinkingLevel?: string | undefined;
+    subagent?: {
+        parentRunId?: string | undefined;
+        spawnedWorkspaceDir?: string | undefined;
+        label?: string | undefined;
+        cleanup?: "delete" | "keep" | undefined;
+        spawnDepth: number;
+        spawnedBy: string;
+        spawnedAt: string;
+    } | undefined;
+    extra?: ArrayBuffer | undefined;
+    agentId: string;
+    sessionKey: string;
+    sessionId: string;
+    createdAt: number;
+    lastUsedAt: number;
+}[]>>;
+export declare const upsertEntry: import("convex/server").RegisteredMutation<"public", {
+    modelId?: string | undefined;
+    provider?: string | undefined;
+    createdAt?: number | undefined;
+    lastUsedAt?: number | undefined;
+    authProfile?: string | undefined;
+    thinkingLevel?: string | undefined;
+    subagent?: {
+        parentRunId?: string | undefined;
+        spawnedWorkspaceDir?: string | undefined;
+        label?: string | undefined;
+        cleanup?: "delete" | "keep" | undefined;
+        spawnDepth: number;
+        spawnedBy: string;
+        spawnedAt: string;
+    } | undefined;
+    extra?: ArrayBuffer | undefined;
+    agentId: string;
+    sessionKey: string;
+    sessionId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"sessions">;
+    _creationTime: number;
+    modelId?: string | undefined;
+    provider?: string | undefined;
+    authProfile?: string | undefined;
+    thinkingLevel?: string | undefined;
+    subagent?: {
+        parentRunId?: string | undefined;
+        spawnedWorkspaceDir?: string | undefined;
+        label?: string | undefined;
+        cleanup?: "delete" | "keep" | undefined;
+        spawnDepth: number;
+        spawnedBy: string;
+        spawnedAt: string;
+    } | undefined;
+    extra?: ArrayBuffer | undefined;
+    agentId: string;
+    sessionKey: string;
+    sessionId: string;
+    createdAt: number;
+    lastUsedAt: number;
+} | null>>;
+export declare const deleteEntry: import("convex/server").RegisteredMutation<"public", {
+    agentId: string;
+    sessionKey: string;
+}, Promise<boolean>>;
+//# sourceMappingURL=sessions.d.ts.map

package/convex/sessions.ts

@@ -0,0 +1,105 @@
+// convex/sessions.ts — sessions index
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+const Subagent = v.object({
+	spawnDepth: v.number(),
+	spawnedBy: v.string(),
+	parentRunId: v.optional(v.string()),
+	label: v.optional(v.string()),
+	cleanup: v.optional(v.union(v.literal("delete"), v.literal("keep"))),
+	spawnedAt: v.string(),
+	spawnedWorkspaceDir: v.optional(v.string()),
+});
+
+export const getEntry = query({
+	args: { agentId: v.string(), sessionKey: v.string() },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("sessions")
+			.withIndex("by_agent_key", (q) =>
+				q.eq("agentId", args.agentId).eq("sessionKey", args.sessionKey),
+			)
+			.first();
+	},
+});
+
+export const listEntries = query({
+	args: { agentId: v.string(), subagentOnly: v.optional(v.boolean()) },
+	handler: async (ctx, args) => {
+		const all = await ctx.db
+			.query("sessions")
+			.withIndex("by_agent_lastUsed", (q) => q.eq("agentId", args.agentId))
+			.order("desc")
+			.collect();
+		if (args.subagentOnly) return all.filter((s) => s.subagent !== undefined);
+		return all;
+	},
+});
+
+export const upsertEntry = mutation({
+	args: {
+		agentId: v.string(),
+		sessionKey: v.string(),
+		sessionId: v.string(),
+		createdAt: v.optional(v.number()),
+		lastUsedAt: v.optional(v.number()),
+		provider: v.optional(v.string()),
+		modelId: v.optional(v.string()),
+		authProfile: v.optional(v.string()),
+		thinkingLevel: v.optional(v.string()),
+		subagent: v.optional(Subagent),
+		extra: v.optional(v.bytes()),
+	},
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("sessions")
+			.withIndex("by_agent_key", (q) =>
+				q.eq("agentId", args.agentId).eq("sessionKey", args.sessionKey),
+			)
+			.first();
+		const now = Date.now();
+		if (existing) {
+			// MERGE, never replace — mirrors the filesystem store's
+			// read-modify-write (src/sessions/session-store.ts): fields the
+			// caller omits keep their stored value, `createdAt` is set once at
+			// creation, and `subagent` is write-once (only applied when the
+			// row doesn't carry one yet — session-store.ts:351-367).
+			const patch: Record<string, unknown> = {
+				sessionId: args.sessionId,
+				lastUsedAt: args.lastUsedAt ?? now,
+			};
+			if (args.provider !== undefined) patch.provider = args.provider;
+			if (args.modelId !== undefined) patch.modelId = args.modelId;
+			if (args.authProfile !== undefined) patch.authProfile = args.authProfile;
+			if (args.thinkingLevel !== undefined) patch.thinkingLevel = args.thinkingLevel;
+			if (args.extra !== undefined) patch.extra = args.extra;
+			if (args.subagent !== undefined && existing.subagent === undefined) {
+				patch.subagent = args.subagent;
+			}
+			await ctx.db.patch(existing._id, patch);
+			return await ctx.db.get(existing._id);
+		}
+		const id = await ctx.db.insert("sessions", {
+			...args,
+			createdAt: args.createdAt ?? now,
+			lastUsedAt: args.lastUsedAt ?? now,
+		});
+		return await ctx.db.get(id);
+	},
+});
+
+export const deleteEntry = mutation({
+	args: { agentId: v.string(), sessionKey: v.string() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("sessions")
+			.withIndex("by_agent_key", (q) =>
+				q.eq("agentId", args.agentId).eq("sessionKey", args.sessionKey),
+			)
+			.first();
+		if (!existing) return false;
+		await ctx.db.delete(existing._id);
+		return true;
+	},
+});

package/convex/skills.d.ts

@@ -0,0 +1,73 @@
+export declare const list: import("convex/server").RegisteredQuery<"public", {
+    agentId?: string | null | undefined;
+    source?: "bundled" | "config" | "managed" | "personal" | "project" | "workspace" | undefined;
+    ownerId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"skills">;
+    _creationTime: number;
+    agentId: string | null;
+    name: string;
+    source: "bundled" | "config" | "managed" | "personal" | "project" | "workspace";
+    description: string;
+    createdAt: number;
+    ownerId: string;
+    updatedAt: number;
+    frontmatter: string;
+    body: string;
+    eligibility: {
+        os: string[];
+        requiresBins: string[];
+        requiresAnyBins: string[];
+        requiresEnv: string[];
+        requiresConfig: string[];
+    };
+    disableModelInvocation: boolean;
+}[]>>;
+export declare const get: import("convex/server").RegisteredQuery<"public", {
+    name: string;
+    ownerId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"skills">;
+    _creationTime: number;
+    agentId: string | null;
+    name: string;
+    source: "bundled" | "config" | "managed" | "personal" | "project" | "workspace";
+    description: string;
+    createdAt: number;
+    ownerId: string;
+    updatedAt: number;
+    frontmatter: string;
+    body: string;
+    eligibility: {
+        os: string[];
+        requiresBins: string[];
+        requiresAnyBins: string[];
+        requiresEnv: string[];
+        requiresConfig: string[];
+    };
+    disableModelInvocation: boolean;
+} | null>>;
+export declare const upsert: import("convex/server").RegisteredMutation<"public", {
+    agentId: string | null;
+    name: string;
+    source: "bundled" | "config" | "managed" | "personal" | "project" | "workspace";
+    description: string;
+    ownerId: string;
+    frontmatter: string;
+    body: string;
+    eligibility: {
+        os: string[];
+        requiresBins: string[];
+        requiresAnyBins: string[];
+        requiresEnv: string[];
+        requiresConfig: string[];
+    };
+    disableModelInvocation: boolean;
+}, Promise<{
+    created: boolean;
+}>>;
+export declare const remove: import("convex/server").RegisteredMutation<"public", {
+    name: string;
+    ownerId: string;
+}, Promise<boolean>>;
+//# sourceMappingURL=skills.d.ts.map

package/convex/skills.ts

@@ -0,0 +1,102 @@
+// convex/skills.ts
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+const Source = v.union(
+	v.literal("bundled"),
+	v.literal("config"),
+	v.literal("managed"),
+	v.literal("personal"),
+	v.literal("project"),
+	v.literal("workspace"),
+);
+
+export const list = query({
+	args: {
+		ownerId: v.string(),
+		// Optional scoping: workspace skills are per-agent, so the mirror sync
+		// must fetch only THIS agent's workspace skills — without it every
+		// agent's skills bleed into every workspace on boot.
+		source: v.optional(Source),
+		agentId: v.optional(v.union(v.string(), v.null())),
+	},
+	handler: async (ctx, args) => {
+		if (args.source !== undefined && args.agentId !== undefined) {
+			const agentId = args.agentId;
+			const source = args.source;
+			return ctx.db
+				.query("skills")
+				.withIndex("by_owner_scope_name", (q) =>
+					q.eq("ownerId", args.ownerId).eq("source", source).eq("agentId", agentId),
+				)
+				.collect();
+		}
+		if (args.source !== undefined) {
+			const source = args.source;
+			return ctx.db
+				.query("skills")
+				.withIndex("by_owner_source", (q) => q.eq("ownerId", args.ownerId).eq("source", source))
+				.collect();
+		}
+		return ctx.db
+			.query("skills")
+			.withIndex("by_owner_source", (q) => q.eq("ownerId", args.ownerId))
+			.collect();
+	},
+});
+
+export const get = query({
+	args: { ownerId: v.string(), name: v.string() },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("skills")
+			.withIndex("by_owner_name", (q) => q.eq("ownerId", args.ownerId).eq("name", args.name))
+			.first();
+	},
+});
+
+export const upsert = mutation({
+	args: {
+		ownerId: v.string(),
+		source: Source,
+		agentId: v.union(v.string(), v.null()),
+		name: v.string(),
+		description: v.string(),
+		frontmatter: v.string(),
+		body: v.string(),
+		eligibility: v.object({
+			os: v.array(v.string()),
+			requiresBins: v.array(v.string()),
+			requiresAnyBins: v.array(v.string()),
+			requiresEnv: v.array(v.string()),
+			requiresConfig: v.array(v.string()),
+		}),
+		disableModelInvocation: v.boolean(),
+	},
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("skills")
+			.withIndex("by_owner_name", (q) => q.eq("ownerId", args.ownerId).eq("name", args.name))
+			.first();
+		const now = Date.now();
+		if (existing) {
+			await ctx.db.replace(existing._id, { ...args, createdAt: existing.createdAt, updatedAt: now });
+			return { created: false };
+		}
+		await ctx.db.insert("skills", { ...args, createdAt: now, updatedAt: now });
+		return { created: true };
+	},
+});
+
+export const remove = mutation({
+	args: { ownerId: v.string(), name: v.string() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("skills")
+			.withIndex("by_owner_name", (q) => q.eq("ownerId", args.ownerId).eq("name", args.name))
+			.first();
+		if (!existing) return false;
+		await ctx.db.delete(existing._id);
+		return true;
+	},
+});

package/convex/subagents.d.ts

@@ -0,0 +1,214 @@
+export declare const get: import("convex/server").RegisteredQuery<"public", {
+    ownerId: string;
+    runId: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"subagentRuns">;
+    _creationTime: number;
+    model?: string | undefined;
+    workspaceDir?: string | undefined;
+    label?: string | undefined;
+    controllerSessionKey?: string | undefined;
+    requesterOrigin?: ArrayBuffer | undefined;
+    runTimeoutSeconds?: number | undefined;
+    spawnMode?: "session" | "run" | undefined;
+    startedAt?: number | undefined;
+    sessionStartedAt?: number | undefined;
+    accumulatedRuntimeMs?: number | undefined;
+    endedAt?: number | undefined;
+    outcome?: {
+        text?: ArrayBuffer | undefined;
+        error?: string | undefined;
+        reason?: string | undefined;
+        status: "error" | "timeout" | "ok" | "abort";
+    } | undefined;
+    archiveAtMs?: number | undefined;
+    cleanupCompletedAt?: number | undefined;
+    cleanupHandled?: boolean | undefined;
+    suppressAnnounceReason?: "steer-restart" | "killed" | undefined;
+    expectsCompletionMessage?: boolean | undefined;
+    announceRetryCount?: number | undefined;
+    lastAnnounceRetryAt?: number | undefined;
+    endedReason?: string | undefined;
+    wakeOnDescendantSettle?: boolean | undefined;
+    frozenResultText?: ArrayBuffer | undefined;
+    frozenResultCapturedAt?: number | undefined;
+    fallbackFrozenResultText?: ArrayBuffer | undefined;
+    fallbackFrozenResultCapturedAt?: number | undefined;
+    endedHookEmittedAt?: number | undefined;
+    completionAnnouncedAt?: number | undefined;
+    attachmentsDir?: string | undefined;
+    attachmentsRootDir?: string | undefined;
+    retainAttachmentsOnKeep?: boolean | undefined;
+    createdAt: number;
+    ownerId: string;
+    cleanup: "delete" | "keep";
+    runId: string;
+    childSessionKey: string;
+    requesterSessionKey: string;
+    requesterDisplayKey: string;
+    task: ArrayBuffer;
+} | null>>;
+export declare const getByChildSessionKey: import("convex/server").RegisteredQuery<"public", {
+    ownerId: string;
+    childSessionKey: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"subagentRuns">;
+    _creationTime: number;
+    model?: string | undefined;
+    workspaceDir?: string | undefined;
+    label?: string | undefined;
+    controllerSessionKey?: string | undefined;
+    requesterOrigin?: ArrayBuffer | undefined;
+    runTimeoutSeconds?: number | undefined;
+    spawnMode?: "session" | "run" | undefined;
+    startedAt?: number | undefined;
+    sessionStartedAt?: number | undefined;
+    accumulatedRuntimeMs?: number | undefined;
+    endedAt?: number | undefined;
+    outcome?: {
+        text?: ArrayBuffer | undefined;
+        error?: string | undefined;
+        reason?: string | undefined;
+        status: "error" | "timeout" | "ok" | "abort";
+    } | undefined;
+    archiveAtMs?: number | undefined;
+    cleanupCompletedAt?: number | undefined;
+    cleanupHandled?: boolean | undefined;
+    suppressAnnounceReason?: "steer-restart" | "killed" | undefined;
+    expectsCompletionMessage?: boolean | undefined;
+    announceRetryCount?: number | undefined;
+    lastAnnounceRetryAt?: number | undefined;
+    endedReason?: string | undefined;
+    wakeOnDescendantSettle?: boolean | undefined;
+    frozenResultText?: ArrayBuffer | undefined;
+    frozenResultCapturedAt?: number | undefined;
+    fallbackFrozenResultText?: ArrayBuffer | undefined;
+    fallbackFrozenResultCapturedAt?: number | undefined;
+    endedHookEmittedAt?: number | undefined;
+    completionAnnouncedAt?: number | undefined;
+    attachmentsDir?: string | undefined;
+    attachmentsRootDir?: string | undefined;
+    retainAttachmentsOnKeep?: boolean | undefined;
+    createdAt: number;
+    ownerId: string;
+    cleanup: "delete" | "keep";
+    runId: string;
+    childSessionKey: string;
+    requesterSessionKey: string;
+    requesterDisplayKey: string;
+    task: ArrayBuffer;
+} | null>>;
+export declare const listByRequester: import("convex/server").RegisteredQuery<"public", {
+    ownerId: string;
+    requesterSessionKey: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"subagentRuns">;
+    _creationTime: number;
+    model?: string | undefined;
+    workspaceDir?: string | undefined;
+    label?: string | undefined;
+    controllerSessionKey?: string | undefined;
+    requesterOrigin?: ArrayBuffer | undefined;
+    runTimeoutSeconds?: number | undefined;
+    spawnMode?: "session" | "run" | undefined;
+    startedAt?: number | undefined;
+    sessionStartedAt?: number | undefined;
+    accumulatedRuntimeMs?: number | undefined;
+    endedAt?: number | undefined;
+    outcome?: {
+        text?: ArrayBuffer | undefined;
+        error?: string | undefined;
+        reason?: string | undefined;
+        status: "error" | "timeout" | "ok" | "abort";
+    } | undefined;
+    archiveAtMs?: number | undefined;
+    cleanupCompletedAt?: number | undefined;
+    cleanupHandled?: boolean | undefined;
+    suppressAnnounceReason?: "steer-restart" | "killed" | undefined;
+    expectsCompletionMessage?: boolean | undefined;
+    announceRetryCount?: number | undefined;
+    lastAnnounceRetryAt?: number | undefined;
+    endedReason?: string | undefined;
+    wakeOnDescendantSettle?: boolean | undefined;
+    frozenResultText?: ArrayBuffer | undefined;
+    frozenResultCapturedAt?: number | undefined;
+    fallbackFrozenResultText?: ArrayBuffer | undefined;
+    fallbackFrozenResultCapturedAt?: number | undefined;
+    endedHookEmittedAt?: number | undefined;
+    completionAnnouncedAt?: number | undefined;
+    attachmentsDir?: string | undefined;
+    attachmentsRootDir?: string | undefined;
+    retainAttachmentsOnKeep?: boolean | undefined;
+    createdAt: number;
+    ownerId: string;
+    cleanup: "delete" | "keep";
+    runId: string;
+    childSessionKey: string;
+    requesterSessionKey: string;
+    requesterDisplayKey: string;
+    task: ArrayBuffer;
+}[]>>;
+export declare const put: import("convex/server").RegisteredMutation<"public", {
+    record: any;
+    ownerId: string;
+}, Promise<void>>;
+export declare const markCompleted: import("convex/server").RegisteredMutation<"public", {
+    error?: string | undefined;
+    endedHookEmittedAt?: number | undefined;
+    reason: string;
+    ownerId: string;
+    runId: string;
+    endedAt: number;
+    outcome: any;
+}, Promise<{
+    _id: import("convex/values").GenericId<"subagentRuns">;
+    _creationTime: number;
+    model?: string | undefined;
+    workspaceDir?: string | undefined;
+    label?: string | undefined;
+    controllerSessionKey?: string | undefined;
+    requesterOrigin?: ArrayBuffer | undefined;
+    runTimeoutSeconds?: number | undefined;
+    spawnMode?: "session" | "run" | undefined;
+    startedAt?: number | undefined;
+    sessionStartedAt?: number | undefined;
+    accumulatedRuntimeMs?: number | undefined;
+    endedAt?: number | undefined;
+    outcome?: {
+        text?: ArrayBuffer | undefined;
+        error?: string | undefined;
+        reason?: string | undefined;
+        status: "error" | "timeout" | "ok" | "abort";
+    } | undefined;
+    archiveAtMs?: number | undefined;
+    cleanupCompletedAt?: number | undefined;
+    cleanupHandled?: boolean | undefined;
+    suppressAnnounceReason?: "steer-restart" | "killed" | undefined;
+    expectsCompletionMessage?: boolean | undefined;
+    announceRetryCount?: number | undefined;
+    lastAnnounceRetryAt?: number | undefined;
+    endedReason?: string | undefined;
+    wakeOnDescendantSettle?: boolean | undefined;
+    frozenResultText?: ArrayBuffer | undefined;
+    frozenResultCapturedAt?: number | undefined;
+    fallbackFrozenResultText?: ArrayBuffer | undefined;
+    fallbackFrozenResultCapturedAt?: number | undefined;
+    endedHookEmittedAt?: number | undefined;
+    completionAnnouncedAt?: number | undefined;
+    attachmentsDir?: string | undefined;
+    attachmentsRootDir?: string | undefined;
+    retainAttachmentsOnKeep?: boolean | undefined;
+    createdAt: number;
+    ownerId: string;
+    cleanup: "delete" | "keep";
+    runId: string;
+    childSessionKey: string;
+    requesterSessionKey: string;
+    requesterDisplayKey: string;
+    task: ArrayBuffer;
+} | null>>;
+export declare const remove: import("convex/server").RegisteredMutation<"public", {
+    ownerId: string;
+    runId: string;
+}, Promise<boolean>>;
+//# sourceMappingURL=subagents.d.ts.map

package/convex/subagents.ts

@@ -0,0 +1,99 @@
+// convex/subagents.ts — subagentRuns
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+export const get = query({
+	args: { ownerId: v.string(), runId: v.string() },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("subagentRuns")
+			.withIndex("by_runId", (q) => q.eq("ownerId", args.ownerId).eq("runId", args.runId))
+			.first();
+	},
+});
+
+export const getByChildSessionKey = query({
+	args: { ownerId: v.string(), childSessionKey: v.string() },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("subagentRuns")
+			.withIndex("by_childSessionKey_active", (q) =>
+				q.eq("ownerId", args.ownerId).eq("childSessionKey", args.childSessionKey),
+			)
+			.order("desc")
+			.first();
+	},
+});
+
+export const listByRequester = query({
+	args: { ownerId: v.string(), requesterSessionKey: v.string() },
+	handler: async (ctx, args) => {
+		return ctx.db
+			.query("subagentRuns")
+			.withIndex("by_requester_createdAt", (q) =>
+				q.eq("ownerId", args.ownerId).eq("requesterSessionKey", args.requesterSessionKey),
+			)
+			.collect();
+	},
+});
+
+export const put = mutation({
+	args: { ownerId: v.string(), record: v.any() },
+	handler: async (ctx, args) => {
+		const record = args.record as Record<string, unknown> & { runId?: string };
+		const runId = record.runId;
+		if (typeof runId !== "string" || runId.length === 0) {
+			throw new Error("subagents.put: record requires `runId`");
+		}
+		const existing = await ctx.db
+			.query("subagentRuns")
+			.withIndex("by_runId", (q) => q.eq("ownerId", args.ownerId).eq("runId", runId))
+			.first();
+		const payload = { ...record, ownerId: args.ownerId };
+		if (existing) {
+			await ctx.db.replace(existing._id, payload as never);
+		} else {
+			await ctx.db.insert("subagentRuns", payload as never);
+		}
+	},
+});
+
+export const markCompleted = mutation({
+	args: {
+		ownerId: v.string(),
+		runId: v.string(),
+		endedAt: v.number(),
+		outcome: v.any(),
+		reason: v.string(),
+		error: v.optional(v.string()),
+		endedHookEmittedAt: v.optional(v.number()),
+	},
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("subagentRuns")
+			.withIndex("by_runId", (q) => q.eq("ownerId", args.ownerId).eq("runId", args.runId))
+			.first();
+		if (!existing) return null;
+		await ctx.db.patch(existing._id, {
+			endedAt: args.endedAt,
+			outcome: args.outcome as never,
+			endedReason: args.reason,
+			...(args.error !== undefined ? { outcome: { ...(args.outcome as object), error: args.error } as never } : {}),
+			...(args.endedHookEmittedAt !== undefined ? { endedHookEmittedAt: args.endedHookEmittedAt } : {}),
+		});
+		return await ctx.db.get(existing._id);
+	},
+});
+
+export const remove = mutation({
+	args: { ownerId: v.string(), runId: v.string() },
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query("subagentRuns")
+			.withIndex("by_runId", (q) => q.eq("ownerId", args.ownerId).eq("runId", args.runId))
+			.first();
+		if (!existing) return false;
+		await ctx.db.delete(existing._id);
+		return true;
+	},
+});