{subtitle}
diff --git a/src/lib/ai-triage.ts b/src/lib/ai-triage.ts
new file mode 100644
index 00000000..df85efd3
--- /dev/null
+++ b/src/lib/ai-triage.ts
@@ -0,0 +1,15 @@
+/**
+ * Technical lease for a single small (512-token) triage completion. This is
+ * not a workspace policy knob: it only bounds ownership of an in-flight
+ * background claim so a process exit cannot strand PENDING forever.
+ */
+export const AI_TRIAGE_PENDING_LEASE_MS = 5 * 60 * 1000;
+
+export function isAiTriagePendingStale(
+ startedAt: Date | string | null | undefined,
+ now = Date.now(),
+): boolean {
+ if (!startedAt) return true;
+ const timestamp = new Date(startedAt).getTime();
+ return !Number.isFinite(timestamp) || now - timestamp >= AI_TRIAGE_PENDING_LEASE_MS;
+}
diff --git a/src/server/routers/__tests__/ai-triage.test.ts b/src/server/routers/__tests__/ai-triage.test.ts
new file mode 100644
index 00000000..5c7b62cf
--- /dev/null
+++ b/src/server/routers/__tests__/ai-triage.test.ts
@@ -0,0 +1,211 @@
+import { afterAll, afterEach, describe, expect, it } from "vitest";
+import { AiTriageStatus, Priority } from "@prisma/client";
+import { aiRouter } from "@/server/routers/ai";
+import { encryptSecret } from "@/server/crypto";
+import { resolveWorkspaceProviderClient } from "@/server/services/ai-providers";
+import {
+ buildContext,
+ createIssue,
+ createWorkspaceFixture,
+ disconnectPrisma,
+ getPrisma,
+ type TestFixture,
+} from "./helpers";
+
+const fixtures: TestFixture[] = [];
+
+afterEach(async () => {
+ while (fixtures.length) await fixtures.pop()!.cleanup();
+});
+
+afterAll(async () => {
+ await disconnectPrisma();
+});
+
+async function setup() {
+ const fixture = await createWorkspaceFixture({ keyPrefix: "AIT" });
+ fixtures.push(fixture);
+ const caller = aiRouter.createCaller(await buildContext(fixture));
+ return { fixture, caller, prisma: getPrisma() };
+}
+
+describe("aiRouter triage lifecycle", () => {
+ it("applies suggestions with full label audit and assignment lifecycle side effects", async () => {
+ const { fixture, caller, prisma } = await setup();
+ const issue = await createIssue(fixture, { title: "Repair Hermes triage" });
+ const [oldAgent, newAgent, label] = await Promise.all([
+ prisma.agent.create({
+ data: {
+ workspaceId: fixture.workspace.id,
+ name: "Old owner",
+ profileKey: "old-owner",
+ },
+ }),
+ prisma.agent.create({
+ data: {
+ workspaceId: fixture.workspace.id,
+ name: "Victor",
+ profileKey: "victor",
+ templateMarkdown: "## Investigation\n\nDocument the root cause.",
+ },
+ }),
+ prisma.label.create({
+ data: {
+ workspaceId: fixture.workspace.id,
+ name: "Bug",
+ color: "#a16207",
+ },
+ }),
+ ]);
+ await prisma.issue.update({
+ where: { id: issue.id },
+ data: {
+ assignedAgentId: oldAgent.id,
+ aiTriageStatus: AiTriageStatus.READY,
+ aiSuggestedPriority: Priority.LOW,
+ aiSuggestedLabelIds: [label.id],
+ aiSuggestedAgentId: newAgent.id,
+ aiTriageReasoning: "Scoped configuration bug.",
+ },
+ });
+ const previousRun = await prisma.agentRun.create({
+ data: {
+ workspaceId: fixture.workspace.id,
+ issueId: issue.id,
+ agentId: oldAgent.id,
+ },
+ });
+ await prisma.issueWatcher.create({
+ data: {
+ workspaceId: fixture.workspace.id,
+ issueId: issue.id,
+ agentId: oldAgent.id,
+ wakeOnActivity: true,
+ },
+ });
+
+ await caller.triageApply({ issueId: issue.id });
+
+ const applied = await prisma.issue.findUniqueOrThrow({
+ where: { id: issue.id },
+ include: { labels: true },
+ });
+ expect(applied).toMatchObject({
+ priority: Priority.LOW,
+ assignedAgentId: newAgent.id,
+ aiTriageStatus: AiTriageStatus.APPLIED,
+ description: "## Investigation\n\nDocument the root cause.",
+ });
+ expect(applied.labels.map((row) => row.labelId)).toEqual([label.id]);
+ expect(applied.dispatchReason).toMatchObject({
+ mode: "MANUAL",
+ picked: "victor",
+ });
+ expect(
+ (await prisma.agentRun.findUniqueOrThrow({ where: { id: previousRun.id } })).status,
+ ).toBe("ABANDONED");
+
+ const watchers = await prisma.issueWatcher.findMany({
+ where: { issueId: issue.id, agentId: { not: null } },
+ select: { agentId: true, wakeOnActivity: true },
+ });
+ expect(watchers).toEqual(
+ expect.arrayContaining([
+ { agentId: oldAgent.id, wakeOnActivity: false },
+ { agentId: newAgent.id, wakeOnActivity: true },
+ ]),
+ );
+
+ const audits = await prisma.auditLog.findMany({
+ where: { entityId: issue.id },
+ select: { action: true },
+ });
+ expect(audits.map((audit) => audit.action)).toEqual(
+ expect.arrayContaining([
+ "ai-triage-apply-priority",
+ "ai-triage-apply-labels",
+ "ai-triage-apply-agent",
+ "apply-agent-template",
+ ]),
+ );
+ const assignmentEvent = await prisma.activityEvent.findFirstOrThrow({
+ where: {
+ subjectId: issue.id,
+ kind: "AGENT_ASSIGNED",
+ },
+ orderBy: { createdAt: "desc" },
+ });
+ expect(assignmentEvent.payload).toMatchObject({
+ agentId: newAgent.id,
+ previousAgentId: oldAgent.id,
+ engagementMode: "EXECUTE",
+ source: "ai-triage",
+ });
+ });
+
+ it("rejects duplicate reruns while triage is pending", async () => {
+ const { fixture, caller, prisma } = await setup();
+ const issue = await createIssue(fixture);
+ await prisma.issue.update({
+ where: { id: issue.id },
+ data: { aiTriageStatus: AiTriageStatus.PENDING, aiTriagedAt: new Date() },
+ });
+
+ await expect(caller.triageRerun({ issueId: issue.id })).rejects.toMatchObject({
+ code: "CONFLICT",
+ });
+ expect((await prisma.issue.findUniqueOrThrow({ where: { id: issue.id } })).aiTriageStatus).toBe(
+ AiTriageStatus.PENDING,
+ );
+ });
+
+ it("does not decide a suggestion when no fields are selected", async () => {
+ const { fixture, caller, prisma } = await setup();
+ const issue = await createIssue(fixture);
+ await prisma.issue.update({
+ where: { id: issue.id },
+ data: { aiTriageStatus: AiTriageStatus.READY },
+ });
+
+ await expect(
+ caller.triageApply({
+ issueId: issue.id,
+ applyPriority: false,
+ applyLabels: false,
+ applyAgent: false,
+ }),
+ ).rejects.toMatchObject({ code: "BAD_REQUEST" });
+ expect((await prisma.issue.findUniqueOrThrow({ where: { id: issue.id } })).aiTriageStatus).toBe(
+ AiTriageStatus.READY,
+ );
+ });
+
+ it("reports and resolves an enabled workspace credential without an env key", async () => {
+ const { fixture, caller, prisma } = await setup();
+ await prisma.workspace.update({
+ where: { id: fixture.workspace.id },
+ data: { aiProvider: "openai", aiModel: null },
+ });
+ await prisma.providerCredential.create({
+ data: {
+ workspaceId: fixture.workspace.id,
+ providerId: "openai",
+ apiKeyEnc: encryptSecret("test-workspace-key"),
+ defaultModel: "workspace-test-model",
+ enabled: true,
+ },
+ });
+
+ const status = await caller.status();
+ expect(status).toMatchObject({
+ activeProvider: "openai",
+ activeProviderAvailable: true,
+ apiKeyConfigured: true,
+ });
+ const resolved = await resolveWorkspaceProviderClient(prisma, fixture.workspace.id, "openai");
+ expect(resolved).toMatchObject({
+ providerId: "openai",
+ defaultModel: "workspace-test-model",
+ });
+ });
+});
diff --git a/src/server/routers/ai.ts b/src/server/routers/ai.ts
index 0dfd6d13..d6308bb7 100644
--- a/src/server/routers/ai.ts
+++ b/src/server/routers/ai.ts
@@ -1,15 +1,22 @@
import { z } from "zod";
import { TRPCError } from "@trpc/server";
import { AgentRole, AiTriageStatus, EventKind } from "@prisma/client";
+import type { EngagementMode } from "@prisma/client";
import { router, workspaceProcedure, adminProcedure } from "@/server/trpc";
import { recordChange } from "@/server/audit";
import { triageIssue } from "@/server/services/ai-triage";
+import { listProviders, runDescriptionDraft, runDescriptionEnhance } from "@/server/services/ai";
import {
- listProviders,
- runDescriptionDraft,
- runDescriptionEnhance,
-} from "@/server/services/ai";
+ resolveWorkspaceProviderClient,
+ workspaceChatProviderAvailability,
+} from "@/server/services/ai-providers";
+import { recordManualDispatchReason } from "@/server/services/dispatcher";
+import { resolveEngagementMode } from "@/server/services/engagement-mode";
+import { maybeApplyAgentTemplate } from "@/server/services/agent-template";
+import { abandonRunsForAgentReassignment } from "@/server/services/agent-run";
+import { setIssueAgentWakeTarget } from "@/server/services/issue-watchers";
import { encryptSecret } from "@/server/crypto";
+import { isAiTriagePendingStale } from "@/lib/ai-triage";
/** Providers that accept a DB-backed key (hermes is a runtime, not a key). */
const CREDENTIAL_PROVIDER_IDS = ["openai", "anthropic", "custom"] as const;
@@ -34,11 +41,16 @@ export const aiRouter = router({
},
select: { id: true, profileKey: true, name: true },
});
- const providers = listProviders();
const ws = await ctx.db.workspace.findUniqueOrThrow({
where: { id: ctx.workspaceId },
select: { aiProvider: true, aiModel: true },
});
+ const isAvailable = await workspaceChatProviderAvailability(ctx.db, ctx.workspaceId);
+ const providers = listProviders().map((provider) => ({
+ ...provider,
+ available: isAvailable(provider.id),
+ unavailableReason: isAvailable(provider.id) ? undefined : provider.unavailableReason,
+ }));
const active = providers.find((p) => p.id === ws.aiProvider) ?? providers[0];
return {
coach,
@@ -78,9 +90,13 @@ export const aiRouter = router({
},
select: { id: true, profileKey: true, name: true, status: true },
});
- const providers = listProviders();
- const provider =
- providers.find((p) => p.id === (ws.aiProvider ?? "hermes")) ?? providers[0];
+ const isAvailable = await workspaceChatProviderAvailability(ctx.db, ctx.workspaceId);
+ const providers = listProviders().map((candidate) => ({
+ ...candidate,
+ available: isAvailable(candidate.id),
+ unavailableReason: isAvailable(candidate.id) ? undefined : candidate.unavailableReason,
+ }));
+ const provider = providers.find((p) => p.id === (ws.aiProvider ?? "hermes")) ?? providers[0];
let lastFired: {
issueId: string;
@@ -164,19 +180,34 @@ export const aiRouter = router({
}),
)
.mutation(async ({ ctx, input }) => {
- // `custom` requires a base URL to be usable.
- if (input.providerId === "custom" && input.baseUrl !== undefined && !input.baseUrl) {
- throw new TRPCError({
- code: "BAD_REQUEST",
- message: "A custom provider needs a base URL.",
- });
- }
const enc = input.apiKey ? encryptSecret(input.apiKey) : undefined;
const norm = (v: string | null | undefined) =>
v === undefined ? undefined : v === "" ? null : v;
const baseUrl = norm(input.baseUrl);
const defaultModel = norm(input.defaultModel);
const label = norm(input.label);
+ // An enabled custom credential is unusable without its endpoint. Check
+ // the effective value so partial edits can keep an existing base URL,
+ // while a new/cleared credential cannot be reported as available.
+ if (input.providerId === "custom") {
+ const existing = await ctx.db.providerCredential.findUnique({
+ where: {
+ workspaceId_providerId: {
+ workspaceId: ctx.workspaceId,
+ providerId: input.providerId,
+ },
+ },
+ select: { baseUrl: true, enabled: true },
+ });
+ const effectiveBaseUrl = baseUrl === undefined ? existing?.baseUrl : baseUrl;
+ const effectiveEnabled = input.enabled ?? existing?.enabled ?? true;
+ if (effectiveEnabled && !effectiveBaseUrl) {
+ throw new TRPCError({
+ code: "BAD_REQUEST",
+ message: "An enabled custom provider needs a base URL.",
+ });
+ }
+ }
const row = await ctx.db.providerCredential.upsert({
where: {
workspaceId_providerId: {
@@ -304,6 +335,12 @@ export const aiRouter = router({
}),
)
.mutation(async ({ ctx, input }) => {
+ if (!input.applyPriority && !input.applyLabels && !input.applyAgent) {
+ throw new TRPCError({
+ code: "BAD_REQUEST",
+ message: "Select at least one suggestion to apply.",
+ });
+ }
return ctx.db.$transaction(async (tx) => {
const issue = await tx.issue.findFirst({
where: {
@@ -328,6 +365,21 @@ export const aiRouter = router({
message: "Triage suggestion is not ready or already decided.",
});
}
+ // Claim the decision before emitting side effects. Concurrent Apply
+ // requests serialize on this row; exactly one can move READY→APPLIED.
+ const claimed = await tx.issue.updateMany({
+ where: { id: issue.id, aiTriageStatus: AiTriageStatus.READY },
+ data: {
+ aiTriageStatus: AiTriageStatus.APPLIED,
+ aiTriageDecidedAt: new Date(),
+ },
+ });
+ if (claimed.count === 0) {
+ throw new TRPCError({
+ code: "CONFLICT",
+ message: "This triage suggestion was already decided.",
+ });
+ }
const updates: {
priority?: typeof issue.priority;
@@ -335,6 +387,13 @@ export const aiRouter = router({
} = {};
const previousPriority = issue.priority;
const previousAgentId = issue.assignedAgentId;
+ let assignedAgent: {
+ id: string;
+ profileKey: string;
+ engagementMode: EngagementMode | null;
+ } | null = null;
+ let previousLabelIds: string[] = [];
+ let addedLabelIds: string[] = [];
if (
input.applyPriority &&
@@ -356,9 +415,12 @@ export const aiRouter = router({
workspaceId: ctx.workspaceId,
archivedAt: null,
},
- select: { id: true },
+ select: { id: true, profileKey: true, engagementMode: true },
});
- if (agent) updates.assignedAgentId = agent.id;
+ if (agent) {
+ assignedAgent = agent;
+ updates.assignedAgentId = agent.id;
+ }
}
if (Object.keys(updates).length > 0) {
@@ -383,9 +445,7 @@ export const aiRouter = router({
select: { labelId: true },
});
const existingSet = new Set(existing.map((e) => e.labelId));
- const toAdd = validLabels
- .map((l) => l.id)
- .filter((id) => !existingSet.has(id));
+ const toAdd = validLabels.map((l) => l.id).filter((id) => !existingSet.has(id));
if (toAdd.length > 0) {
await tx.issueLabel.createMany({
data: toAdd.map((labelId) => ({
@@ -394,6 +454,8 @@ export const aiRouter = router({
})),
skipDuplicates: true,
});
+ previousLabelIds = Array.from(existingSet);
+ addedLabelIds = toAdd;
}
}
@@ -420,7 +482,49 @@ export const aiRouter = router({
userAgent: ctx.userAgent,
});
}
- if (updates.assignedAgentId) {
+ if (addedLabelIds.length > 0) {
+ await recordChange(tx, {
+ workspaceId: ctx.workspaceId,
+ actorId: ctx.session.user.id,
+ actorAgentId: ctx.apiKey?.linkedAgentId ?? null,
+ entity: "Issue",
+ entityId: issue.id,
+ action: "ai-triage-apply-labels",
+ before: { labelIds: previousLabelIds },
+ after: { labelIds: [...previousLabelIds, ...addedLabelIds] },
+ eventKind: EventKind.ISSUE_UPDATED,
+ subjectType: "issue",
+ subjectId: issue.id,
+ payload: {
+ labelIds: addedLabelIds,
+ operation: "add",
+ source: "ai-triage",
+ },
+ ip: ctx.ip,
+ userAgent: ctx.userAgent,
+ });
+ }
+ if (updates.assignedAgentId && assignedAgent) {
+ const manualReason = await recordManualDispatchReason(tx, {
+ issueId: issue.id,
+ agentProfileKey: assignedAgent.profileKey,
+ actorId: ctx.session.user.id,
+ });
+ const ws = await tx.workspace.findUniqueOrThrow({
+ where: { id: ctx.workspaceId },
+ select: {
+ assignmentEngagementMode: true,
+ mentionEngagementPolicy: true,
+ mentionDefaultMode: true,
+ },
+ });
+ const resolved = resolveEngagementMode({
+ surface: "assignment",
+ workspace: {
+ ...ws,
+ assignmentAgentEngagementMode: assignedAgent.engagementMode,
+ },
+ });
await recordChange(tx, {
workspaceId: ctx.workspaceId,
actorId: ctx.session.user.id,
@@ -435,21 +539,32 @@ export const aiRouter = router({
payload: {
agentId: updates.assignedAgentId,
previousAgentId,
+ dispatchReason: manualReason,
+ engagementMode: resolved.mode,
+ engagementSource: resolved.source,
source: "ai-triage",
},
ip: ctx.ip,
userAgent: ctx.userAgent,
});
+ if (previousAgentId) {
+ await abandonRunsForAgentReassignment(tx, {
+ workspaceId: ctx.workspaceId,
+ issueId: issue.id,
+ agentId: previousAgentId,
+ actorId: ctx.session.user.id,
+ actorAgentId: ctx.apiKey?.linkedAgentId ?? null,
+ summary: "Abandoned because AI triage reassigned the issue to another agent.",
+ });
+ }
+ await maybeApplyAgentTemplate(tx, issue.id, assignedAgent.id);
+ await setIssueAgentWakeTarget(tx, {
+ workspaceId: ctx.workspaceId,
+ issueId: issue.id,
+ agentId: assignedAgent.id,
+ });
}
- await tx.issue.update({
- where: { id: issue.id },
- data: {
- aiTriageStatus: AiTriageStatus.APPLIED,
- aiTriageDecidedAt: new Date(),
- },
- });
-
return { ok: true };
});
}),
@@ -500,12 +615,21 @@ export const aiRouter = router({
workspaceId: ctx.workspaceId,
deletedAt: null,
},
- select: { id: true },
+ select: { id: true, aiTriageStatus: true, aiTriagedAt: true },
});
if (!issue) throw new TRPCError({ code: "NOT_FOUND" });
+ if (
+ issue.aiTriageStatus === AiTriageStatus.PENDING &&
+ !isAiTriagePendingStale(issue.aiTriagedAt)
+ ) {
+ throw new TRPCError({
+ code: "CONFLICT",
+ message: "AI triage is already running for this issue.",
+ });
+ }
// Reset state so the runner doesn't short-circuit.
- await ctx.db.issue.update({
- where: { id: issue.id },
+ const reset = await ctx.db.issue.updateMany({
+ where: { id: issue.id, aiTriageStatus: issue.aiTriageStatus },
data: {
aiTriageStatus: null,
aiTriagedAt: null,
@@ -516,6 +640,12 @@ export const aiRouter = router({
aiTriageReasoning: null,
},
});
+ if (reset.count === 0) {
+ throw new TRPCError({
+ code: "CONFLICT",
+ message: "The triage state changed. Try again.",
+ });
+ }
void triageIssue(issue.id);
return { ok: true };
}),
@@ -542,15 +672,21 @@ export const aiRouter = router({
if (!issue.workspace.aiEnabled)
throw new TRPCError({
code: "PRECONDITION_FAILED",
- message:
- "AI is off for this workspace. Enable it in Settings → Workspace → AI.",
+ message: "AI is off for this workspace. Enable it in Settings → Workspace → AI.",
});
- const markdown = await runDescriptionDraft({
- title: issue.title,
- description: issue.description,
- provider: issue.workspace.aiProvider,
- model: issue.workspace.aiModel,
- });
+ const providerClient = await resolveWorkspaceProviderClient(
+ ctx.db,
+ ctx.workspaceId,
+ issue.workspace.aiProvider,
+ );
+ const markdown = providerClient
+ ? await runDescriptionDraft(providerClient, {
+ title: issue.title,
+ description: issue.description,
+ provider: issue.workspace.aiProvider,
+ model: issue.workspace.aiModel,
+ })
+ : null;
if (!markdown)
throw new TRPCError({
code: "BAD_GATEWAY",
@@ -582,15 +718,21 @@ export const aiRouter = router({
if (!issue.workspace.aiEnabled)
throw new TRPCError({
code: "PRECONDITION_FAILED",
- message:
- "AI is off for this workspace. Enable it in Settings → Workspace → AI.",
+ message: "AI is off for this workspace. Enable it in Settings → Workspace → AI.",
});
- const markdown = await runDescriptionEnhance({
- title: issue.title,
- description: issue.description,
- provider: issue.workspace.aiProvider,
- model: issue.workspace.aiModel,
- });
+ const providerClient = await resolveWorkspaceProviderClient(
+ ctx.db,
+ ctx.workspaceId,
+ issue.workspace.aiProvider,
+ );
+ const markdown = providerClient
+ ? await runDescriptionEnhance(providerClient, {
+ title: issue.title,
+ description: issue.description,
+ provider: issue.workspace.aiProvider,
+ model: issue.workspace.aiModel,
+ })
+ : null;
if (!markdown)
throw new TRPCError({
code: "BAD_GATEWAY",
@@ -653,10 +795,7 @@ export const aiRouter = router({
});
/** Format a Hermes gateway response into a compact markdown block. */
-function formatHermesInfo(
- resource: "skills" | "memory" | "health",
- data: unknown,
-): string {
+function formatHermesInfo(resource: "skills" | "memory" | "health", data: unknown): string {
if (data == null) return `_No ${resource} data returned._`;
if (resource === "skills") {
const list = Array.isArray(data)
diff --git a/src/server/routers/inbox.ts b/src/server/routers/inbox.ts
index 35ada2ee..9d88c013 100644
--- a/src/server/routers/inbox.ts
+++ b/src/server/routers/inbox.ts
@@ -641,7 +641,7 @@ export const inboxRouter = router({
? { updatedAt: { gt: lastVisitAt } }
: {};
- const [assignedCount, stalledCount, candidates] = await Promise.all([
+ const [assignedCount, stalledCount, candidates, actionRequestCount] = await Promise.all([
ctx.db.issue.count({
where: {
workspaceId: { in: workspaceIds },
@@ -674,15 +674,26 @@ export const inboxRouter = router({
createdAt: lastVisitAt
? { gte: mentionCutoff, gt: lastVisitAt }
: { gte: mentionCutoff },
- authorId: { not: userId },
+ // Agent comments can carry the API-key owner's authorId. Treat
+ // authoringAgentId as authoritative so those mentions are not
+ // mistaken for self-mentions.
+ OR: [{ authoringAgentId: { not: null } }, { authorId: { not: userId } }],
},
select: { body: true },
take: 100,
}),
+ ctx.db.actionRequest.count({
+ where: {
+ workspaceId: { in: workspaceIds },
+ assignedUserId: userId,
+ status: "OPEN",
+ ...(lastVisitAt ? { createdAt: { gt: lastVisitAt } } : {}),
+ },
+ }),
]);
const mentionCount = candidates.filter((c) => commentMentionsUser(c.body, tokens)).length;
// Cap the badge count because the sidebar treatment is "1-99+".
- const raw = assignedCount + stalledCount + mentionCount;
+ const raw = assignedCount + stalledCount + mentionCount + actionRequestCount;
return { count: raw };
}),
});
diff --git a/src/server/services/ai-coach.ts b/src/server/services/ai-coach.ts
index 94f209a3..ed423df3 100644
--- a/src/server/services/ai-coach.ts
+++ b/src/server/services/ai-coach.ts
@@ -3,6 +3,7 @@ import type { Prisma, PrismaClient } from "@prisma/client";
import { AgentRole, EventKind } from "@prisma/client";
import { logger } from "@/server/logger";
import { runCoachComment } from "@/server/services/ai";
+import { resolveWorkspaceProviderClient } from "@/server/services/ai-providers";
import { recordChange } from "@/server/audit";
/**
@@ -11,7 +12,8 @@ import { recordChange } from "@/server/audit";
* diagnostic comment when:
* - the workspace has aiEnabled = true AND aiCoachEnabled = true
* - a COACH-role agent exists for the workspace
- * - ANTHROPIC_API_KEY is set
+ * - the selected workspace provider is available via a stored credential
+ * or environment fallback
*
* Failures are swallowed and logged. The Coach is decorative — never
* blocks the underlying event flow.
@@ -91,7 +93,14 @@ export async function coachOnEvent(
.reverse()
.map((c) => c.body);
- const body = await runCoachComment({
+ const providerClient = await resolveWorkspaceProviderClient(
+ client,
+ params.workspaceId,
+ ws.aiProvider,
+ );
+ if (!providerClient) return;
+
+ const body = await runCoachComment(providerClient, {
eventKind: params.eventKind,
issue: {
id: issue.id,
diff --git a/src/server/services/ai-providers.ts b/src/server/services/ai-providers.ts
index e18477a6..8c4b8342 100644
--- a/src/server/services/ai-providers.ts
+++ b/src/server/services/ai-providers.ts
@@ -1,6 +1,6 @@
import "server-only";
import OpenAI from "openai";
-import type { PrismaClient } from "@prisma/client";
+import type { Prisma, PrismaClient } from "@prisma/client";
import { logger } from "@/server/logger";
import { decryptSecret } from "@/server/crypto";
@@ -76,8 +76,7 @@ const PROVIDERS: Record
= {
supportsImageInput: true,
resolve: () => {
const apiKey = process.env.OPENAI_API_KEY;
- if (!apiKey)
- return { ok: false, reason: "OPENAI_API_KEY not set" };
+ if (!apiKey) return { ok: false, reason: "OPENAI_API_KEY not set" };
const baseURL = process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1";
return { ok: true, baseURL, apiKey };
},
@@ -85,14 +84,12 @@ const PROVIDERS: Record = {
anthropic: {
id: "anthropic",
label: "Anthropic (direct)",
- description:
- "Anthropic's OpenAI-compatible endpoint. Set ANTHROPIC_API_KEY.",
+ description: "Anthropic's OpenAI-compatible endpoint. Set ANTHROPIC_API_KEY.",
defaultModel: "claude-haiku-4-5-20251001",
supportsImageInput: true,
resolve: () => {
const apiKey = process.env.ANTHROPIC_API_KEY;
- if (!apiKey)
- return { ok: false, reason: "ANTHROPIC_API_KEY not set" };
+ if (!apiKey) return { ok: false, reason: "ANTHROPIC_API_KEY not set" };
// Anthropic's OpenAI-compat surface lives under /v1/.
return {
ok: true,
@@ -161,9 +158,7 @@ export function isProviderAvailable(id: string | null | undefined): boolean {
* Build a configured OpenAI SDK client for the named provider, or null
* if its env isn't set up. Callers treat null as "AI unavailable".
*/
-export function getClient(
- providerId: string | null | undefined,
-): {
+export function getClient(providerId: string | null | undefined): {
client: OpenAI;
defaultModel: string;
providerId: ProviderId;
@@ -172,10 +167,7 @@ export function getClient(
const provider = getProvider(providerId);
const r = provider.resolve();
if (!r.ok) {
- logger.warn(
- { provider: provider.id, reason: r.reason },
- "ai-providers: provider unavailable",
- );
+ logger.warn({ provider: provider.id, reason: r.reason }, "ai-providers: provider unavailable");
return null;
}
return {
@@ -235,7 +227,7 @@ function canonicalBaseFor(
* "no chat model configured" notice — never falls back to another platform).
*/
export async function resolveWorkspaceProviderClient(
- db: PrismaClient,
+ db: PrismaClient | Prisma.TransactionClient,
workspaceId: string,
providerId: string | null | undefined,
): Promise {
@@ -247,10 +239,7 @@ export async function resolveWorkspaceProviderClient(
if (cred && cred.enabled && cred.apiKeyEnc) {
const base = canonicalBaseFor(provider.id, cred.baseUrl);
if (!base) {
- logger.warn(
- { provider: provider.id },
- "ai-providers: custom credential missing base URL",
- );
+ logger.warn({ provider: provider.id }, "ai-providers: custom credential missing base URL");
return getClient(provider.id);
}
let apiKey: string;
@@ -276,13 +265,18 @@ export async function resolveWorkspaceProviderClient(
* to decide if a Completions turn will reach a model. One query, sync predicate.
*/
export async function workspaceChatProviderAvailability(
- db: PrismaClient,
+ db: PrismaClient | Prisma.TransactionClient,
workspaceId: string,
): Promise<(providerId: string) => boolean> {
const creds = await db.providerCredential.findMany({
where: { workspaceId, enabled: true, NOT: { apiKeyEnc: null } },
- select: { providerId: true },
+ select: { providerId: true, baseUrl: true },
});
- const dbSet = new Set(creds.map((c) => c.providerId));
- return (providerId: string) => dbSet.has(getProvider(providerId).id) || isProviderAvailable(providerId);
+ const dbSet = new Set(
+ creds
+ .filter((credential) => credential.providerId !== "custom" || credential.baseUrl?.trim())
+ .map((credential) => credential.providerId),
+ );
+ return (providerId: string) =>
+ dbSet.has(getProvider(providerId).id) || isProviderAvailable(providerId);
}
diff --git a/src/server/services/ai-triage.ts b/src/server/services/ai-triage.ts
index 2495a01c..7982eefb 100644
--- a/src/server/services/ai-triage.ts
+++ b/src/server/services/ai-triage.ts
@@ -2,18 +2,19 @@ import "server-only";
import { AiTriageStatus, AgentRole } from "@prisma/client";
import { db } from "@/server/db";
import { logger } from "@/server/logger";
-import { runTriage, aiAvailable } from "@/server/services/ai";
+import { runTriage } from "@/server/services/ai";
+import { resolveWorkspaceProviderClient } from "@/server/services/ai-providers";
/**
* Background-runnable triage routine. Loads the issue + workspace context,
* calls the AI service, persists the suggestion. Always idempotent: a
- * second run for the same issue is a no-op once `aiTriageStatus` is
- * non-null and not `PENDING`.
+ * second run for the same issue is a no-op once `aiTriageStatus` is non-null.
*
* Caller is responsible for fire-and-forget — this function never throws
* out (it logs and writes ERROR status on failure).
*/
export async function triageIssue(issueId: string): Promise {
+ let claimStartedAt: Date | null = null;
try {
const issue = await db.issue.findUnique({
where: { id: issueId },
@@ -22,7 +23,6 @@ export async function triageIssue(issueId: string): Promise {
workspaceId: true,
title: true,
description: true,
- aiTriageStatus: true,
workspace: {
select: {
aiEnabled: true,
@@ -35,14 +35,41 @@ export async function triageIssue(issueId: string): Promise {
});
if (!issue) return;
if (!issue.workspace.aiEnabled || !issue.workspace.aiTriageOnCreate) return;
- // Idempotent: if we already ran (or someone is running concurrently),
- // skip. PENDING means a sibling call is in flight.
- if (issue.aiTriageStatus !== null) return;
-
- await db.issue.update({
- where: { id: issueId },
- data: { aiTriageStatus: AiTriageStatus.PENDING },
+ // Atomic claim: two create/rerun workers can observe the same null state,
+ // but only one is allowed to transition it to PENDING and call the model.
+ claimStartedAt = new Date();
+ const claimed = await db.issue.updateMany({
+ where: { id: issueId, aiTriageStatus: null },
+ data: {
+ aiTriageStatus: AiTriageStatus.PENDING,
+ aiTriagedAt: claimStartedAt,
+ },
});
+ if (claimed.count === 0) {
+ claimStartedAt = null;
+ return;
+ }
+
+ const providerClient = await resolveWorkspaceProviderClient(
+ db,
+ issue.workspaceId,
+ issue.workspace.aiProvider,
+ );
+ if (!providerClient) {
+ await db.issue.updateMany({
+ where: {
+ id: issueId,
+ aiTriageStatus: AiTriageStatus.PENDING,
+ aiTriagedAt: claimStartedAt,
+ },
+ data: {
+ aiTriageStatus: AiTriageStatus.ERROR,
+ aiTriageReasoning: `The “${issue.workspace.aiProvider ?? "hermes"}” AI provider isn't configured for this workspace. Set it up in Settings → Workspace → AI.`,
+ aiTriagedAt: new Date(),
+ },
+ });
+ return;
+ }
const [labels, agents, recent] = await Promise.all([
db.label.findMany({
@@ -75,7 +102,7 @@ export async function triageIssue(issueId: string): Promise {
}),
]);
- const suggestion = await runTriage({
+ const suggestion = await runTriage(providerClient, {
title: issue.title,
description: issue.description,
workspaceLabels: labels,
@@ -86,24 +113,28 @@ export async function triageIssue(issueId: string): Promise {
});
if (!suggestion) {
- // Distinguish "provider not wired up" from "model gave nothing usable"
- // so the card can show an actionable reason instead of a bare error.
- const reason = aiAvailable(issue.workspace.aiProvider)
- ? "The model didn't return a usable triage suggestion. Try Re-run, or switch the AI provider/model in Settings → Workspace → AI."
- : `The “${issue.workspace.aiProvider ?? "hermes"}” AI provider isn't configured for this workspace. Set it up in Settings → Workspace → AI.`;
- await db.issue.update({
- where: { id: issueId },
+ await db.issue.updateMany({
+ where: {
+ id: issueId,
+ aiTriageStatus: AiTriageStatus.PENDING,
+ aiTriagedAt: claimStartedAt,
+ },
data: {
aiTriageStatus: AiTriageStatus.ERROR,
- aiTriageReasoning: reason,
+ aiTriageReasoning:
+ "The model didn't return a usable triage suggestion. Try Re-run, or switch the AI provider/model in Settings → Workspace → AI.",
aiTriagedAt: new Date(),
},
});
return;
}
- await db.issue.update({
- where: { id: issueId },
+ await db.issue.updateMany({
+ where: {
+ id: issueId,
+ aiTriageStatus: AiTriageStatus.PENDING,
+ aiTriagedAt: claimStartedAt,
+ },
data: {
aiTriageStatus: AiTriageStatus.READY,
aiSuggestedPriority: suggestion.priority,
@@ -115,9 +146,14 @@ export async function triageIssue(issueId: string): Promise {
});
} catch (err) {
logger.warn({ err, issueId }, "ai-triage: unexpected failure");
+ if (!claimStartedAt) return;
await db.issue
- .update({
- where: { id: issueId },
+ .updateMany({
+ where: {
+ id: issueId,
+ aiTriageStatus: AiTriageStatus.PENDING,
+ aiTriagedAt: claimStartedAt,
+ },
data: {
aiTriageStatus: AiTriageStatus.ERROR,
aiTriageReasoning:
diff --git a/src/server/services/ai.ts b/src/server/services/ai.ts
index 8228dead..659f6779 100644
--- a/src/server/services/ai.ts
+++ b/src/server/services/ai.ts
@@ -2,12 +2,7 @@ import "server-only";
import { Priority } from "@prisma/client";
import type OpenAI from "openai";
import { logger } from "@/server/logger";
-import {
- getClient,
- isProviderAvailable,
- listProviders,
- type ResolvedProviderClient,
-} from "@/server/services/ai-providers";
+import { listProviders, type ResolvedProviderClient } from "@/server/services/ai-providers";
/**
* AI service — provider-agnostic wrapper around OpenAI's
@@ -66,20 +61,11 @@ export interface CoachInput {
model?: string | null;
}
-/** Whether the named provider has its env wired up. */
-export function aiAvailable(provider?: string | null): boolean {
- return isProviderAvailable(provider ?? "hermes");
-}
-
export async function runTriage(
+ ctx: ResolvedProviderClient,
input: TriageInput,
): Promise {
- const ctx = getClient(input.provider);
- if (!ctx) return null;
-
- const labelMenu = input.workspaceLabels
- .map((l) => `- ${l.name} (id: ${l.id})`)
- .join("\n");
+ const labelMenu = input.workspaceLabels.map((l) => `- ${l.name} (id: ${l.id})`).join("\n");
const agentMenu = input.agents.length
? input.agents
.map(
@@ -104,7 +90,7 @@ ${labelMenu || "(none configured)"}
Available agents:
${agentMenu}${recentBlock}
-Suggest a priority, applicable labels (only from the list above — match by id, not name), and an agent assignment if one of the available agents is a clear fit. Skip agent assignment if no agent is a strong match. Include a 1-2 sentence reasoning the operator can read at a glance.`;
+Suggest a priority, applicable labels (only from the list above), and an agent assignment if one of the available agents is a clear fit. Return label and agent ids when possible. Skip agent assignment if no agent is a strong match. Include a 1-2 sentence reasoning the operator can read at a glance.`;
const tools: OpenAI.Chat.Completions.ChatCompletionTool[] = [
{
@@ -122,13 +108,11 @@ Suggest a priority, applicable labels (only from the list above — match by id,
label_ids: {
type: "array",
items: { type: "string" },
- description:
- "IDs from the workspace labels list. Empty array if no labels apply.",
+ description: "IDs from the workspace labels list. Empty array if no labels apply.",
},
agent_id: {
type: ["string", "null"],
- description:
- "Agent id from the available agents list, or null if no clear fit.",
+ description: "Agent id from the available agents list, or null if no clear fit.",
},
reasoning: {
type: "string",
@@ -143,34 +127,41 @@ Suggest a priority, applicable labels (only from the list above — match by id,
let completion: OpenAI.Chat.Completions.ChatCompletion;
try {
- completion = await ctx.client.chat.completions.create({
+ const structuredPrompt =
+ "You are a triage assistant for a project management tool. Be conservative — prefer NONE/LOW priority unless the issue clearly indicates urgency, and don't assign an agent unless one is a strong capability match. Do not invent label ids or agent ids; only use values from the provided lists.";
+ const request: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming = {
model: input.model || ctx.defaultModel,
max_tokens: 512,
messages: [
{
role: "system",
content:
- "You are a triage assistant for a project management tool. Make a single tool call to submit_triage. Be conservative — prefer NONE/LOW priority unless the issue clearly indicates urgency, and don't assign an agent unless one is a strong capability match. Do not invent label ids or agent ids; only use values from the provided lists.",
+ ctx.providerId === "hermes"
+ ? `${structuredPrompt} Return exactly one JSON object with keys priority, label_ids, agent_id, and reasoning. Do not call tools, add a preamble, or wrap the JSON in Markdown.`
+ : `${structuredPrompt} Make a single tool call to submit_triage.`,
},
{ role: "user", content: userMessage },
],
- tools,
- tool_choice: { type: "function", function: { name: "submit_triage" } },
- });
+ ...(ctx.providerId === "hermes"
+ ? {}
+ : {
+ tools,
+ tool_choice: {
+ type: "function" as const,
+ function: { name: "submit_triage" },
+ },
+ }),
+ };
+ completion = await ctx.client.chat.completions.create(request);
} catch (err) {
- logger.warn(
- { err, provider: ctx.providerId },
- "ai.triage: chat call failed",
- );
+ logger.warn({ err, provider: ctx.providerId }, "ai.triage: chat call failed");
return null;
}
- const validLabelIds = new Set(input.workspaceLabels.map((l) => l.id));
- const validAgentIds = new Set(input.agents.map((a) => a.id));
const suggestion = parseTriageMessage(
completion.choices?.[0]?.message,
- validLabelIds,
- validAgentIds,
+ input.workspaceLabels,
+ input.agents,
);
if (!suggestion) {
logger.warn(
@@ -199,19 +190,15 @@ const PRIORITY_PATTERN = "NONE|LOW|MEDIUM|HIGH|URGENT";
export function parseTriageMessage(
message: unknown,
- validLabelIds: Set,
- validAgentIds: Set,
+ labels: Array<{ id: string; name: string }>,
+ agents: Array<{ id: string; profileKey: string; name: string }>,
): TriageSuggestion | null {
for (const payload of triagePayloadCandidates(message)) {
- const fromPayload = suggestionFromPayload(
- payload,
- validLabelIds,
- validAgentIds,
- );
+ const fromPayload = suggestionFromPayload(payload, labels, agents);
if (fromPayload) return fromPayload;
}
const text = messageTextContent(message);
- if (text) return suggestionFromProse(text, validLabelIds, validAgentIds);
+ if (text) return suggestionFromProse(text, labels, agents);
return null;
}
@@ -268,95 +255,174 @@ function jsonRecord(value: unknown): Record | null {
function suggestionFromPayload(
parsed: Record,
- validLabelIds: Set,
- validAgentIds: Set,
+ labels: Array<{ id: string; name: string }>,
+ agents: Array<{ id: string; profileKey: string; name: string }>,
): TriageSuggestion | null {
const reasoning =
typeof parsed.reasoning === "string" && parsed.reasoning.trim()
- ? parsed.reasoning.trim().slice(0, 1000)
+ ? cleanTriageReasoning(parsed.reasoning)
: null;
// Guard against arbitrary JSON that isn't a triage payload (e.g. a stray
// object embedded in prose): it must carry a priority or a reasoning.
if (!("priority" in parsed) && reasoning === null) return null;
- const priority = isPriority(parsed.priority) ? parsed.priority : Priority.NONE;
+ const priority = coercePriority(parsed.priority) ?? Priority.NONE;
const rawLabels = Array.isArray(parsed.label_ids)
? parsed.label_ids
: Array.isArray(parsed.labelIds)
? parsed.labelIds
: [];
- const labelIds = rawLabels
- .filter((x): x is string => typeof x === "string")
- .filter((id) => validLabelIds.has(id));
+ const labelIds = Array.from(
+ new Set(
+ rawLabels
+ .filter((x): x is string => typeof x === "string")
+ .map((value) => matchLabel(value, labels))
+ .filter((id): id is string => id !== null),
+ ),
+ );
const agentRaw = parsed.agent_id ?? parsed.agentId;
- const agentId =
- typeof agentRaw === "string" && validAgentIds.has(agentRaw)
- ? agentRaw
- : null;
+ const agentId = typeof agentRaw === "string" ? matchAgent(agentRaw, agents) : null;
return {
priority,
labelIds,
agentId,
- reasoning: reasoning ?? "(no reasoning provided)",
+ reasoning: reasoning ?? "Suggested from the issue's current context.",
};
}
function suggestionFromProse(
text: string,
- validLabelIds: Set,
- validAgentIds: Set,
+ labels: Array<{ id: string; name: string }>,
+ agents: Array<{ id: string; profileKey: string; name: string }>,
): TriageSuggestion | null {
const priority = prosePriority(text);
if (!priority) return null; // no recognizable triage signal — let caller ERROR.
- // ids are unique cuids, so a substring scan is the most format-robust match
- // regardless of how the model formatted the prose.
- const labelIds = [...validLabelIds].filter((id) => text.includes(id));
- const agentId = [...validAgentIds].find((id) => text.includes(id)) ?? null;
+ // IDs are safe to match anywhere. Human-readable names are only accepted
+ // from explicit Labels/Agent clauses so a name in the rationale cannot
+ // silently assign work to somebody.
+ const labelIds = labels.filter((label) => text.includes(label.id)).map((label) => label.id);
+ const labelClause = text.match(
+ /\blabels?\b\s*(?::|-|are)?\s*([^;\n.]+?)(?=\s+(?:and\s+)?assign(?:ed|ment)?\b|[;\n.]|$)/i,
+ )?.[1];
+ if (labelClause) {
+ for (const label of labels) {
+ if (containsNormalizedPhrase(labelClause, label.name)) labelIds.push(label.id);
+ }
+ }
+
+ let agentId = agents.find((agent) => text.includes(agent.id))?.id ?? null;
+ if (!agentId) {
+ const agentClause =
+ text.match(/\b(?:agent|assignee)\s*[:\-]\s*([^;\n.]+)/i)?.[1] ??
+ text.match(/\bassign(?:ed)?(?:\s+to)?\s+([^;\n.]+)/i)?.[1];
+ if (agentClause && !/^\s*(?:none|null|n\/a)\b/i.test(agentClause)) {
+ agentId = matchAgentPhrase(agentClause, agents);
+ }
+ }
const reasonMatch = text.match(/reasoning[\s*_]*[:\-]\s*([\s\S]+)/i);
- const reasoning = (reasonMatch?.[1]?.trim() || text.trim()).slice(0, 1000);
+ const reasoning = cleanTriageReasoning(reasonMatch?.[1] ?? text);
- return { priority, labelIds, agentId, reasoning };
+ return { priority, labelIds: Array.from(new Set(labelIds)), agentId, reasoning };
+}
+
+function normalizeTriageToken(value: string): string {
+ return value
+ .normalize("NFKD")
+ .toLocaleLowerCase()
+ .replace(/[^\p{L}\p{N}]+/gu, " ")
+ .trim();
+}
+
+function containsNormalizedPhrase(haystack: string, needle: string): boolean {
+ const normalizedHaystack = ` ${normalizeTriageToken(haystack)} `;
+ const normalizedNeedle = normalizeTriageToken(needle);
+ return normalizedNeedle.length > 0 && normalizedHaystack.includes(` ${normalizedNeedle} `);
+}
+
+function matchLabel(value: string, labels: Array<{ id: string; name: string }>): string | null {
+ const exact = labels.find((label) => label.id === value);
+ if (exact) return exact.id;
+ const normalized = normalizeTriageToken(value);
+ const matches = labels.filter((label) => normalizeTriageToken(label.name) === normalized);
+ return new Set(matches.map((label) => label.id)).size === 1 ? matches[0]!.id : null;
+}
+
+function matchAgent(
+ value: string,
+ agents: Array<{ id: string; profileKey: string; name: string }>,
+): string | null {
+ const exact = agents.find((agent) => agent.id === value || agent.profileKey === value);
+ if (exact) return exact.id;
+ const normalized = normalizeTriageToken(value);
+ const matches = agents.filter(
+ (agent) =>
+ normalizeTriageToken(agent.profileKey) === normalized ||
+ normalizeTriageToken(agent.name) === normalized,
+ );
+ return new Set(matches.map((agent) => agent.id)).size === 1 ? matches[0]!.id : null;
+}
+
+function matchAgentPhrase(
+ value: string,
+ agents: Array<{ id: string; profileKey: string; name: string }>,
+): string | null {
+ const matches = agents.filter(
+ (agent) =>
+ value.includes(agent.id) ||
+ containsNormalizedPhrase(value, agent.profileKey) ||
+ containsNormalizedPhrase(value, agent.name),
+ );
+ return new Set(matches.map((agent) => agent.id)).size === 1 ? matches[0]!.id : null;
+}
+
+function cleanTriageReasoning(value: string): string {
+ const sentences = value
+ .trim()
+ .split(/(?<=[.!?])\s+|\r?\n+/)
+ .map((sentence) => sentence.trim())
+ .filter(Boolean)
+ .filter(
+ (sentence) =>
+ !/(?:submit_triage|triage submission failed)/i.test(sentence) &&
+ !/^recommended triage\b/i.test(sentence) &&
+ !/^(?:priority|labels?|agent|assignee)\s*[:\-]/i.test(sentence),
+ );
+ const cleaned = sentences.join(" ").trim();
+ return (cleaned || "Suggested from the issue's current context.").slice(0, 1000);
}
function prosePriority(text: string): Priority | null {
const labelled = text.match(
- new RegExp(
- `priority[\\s*_]*[:\\-]?\\s*\\*{0,2}\\s*(${PRIORITY_PATTERN})`,
- "i",
- ),
+ new RegExp(`priority[\\s*_]*[:\\-]?\\s*\\*{0,2}\\s*(${PRIORITY_PATTERN})`, "i"),
);
- const token =
- labelled?.[1] ??
- text.match(new RegExp(`\\b(${PRIORITY_PATTERN})\\b`, "i"))?.[1];
+ const token = labelled?.[1] ?? text.match(new RegExp(`\\b(${PRIORITY_PATTERN})\\b`, "i"))?.[1];
if (!token) return null;
- const upper = token.toUpperCase();
+ return coercePriority(token);
+}
+
+function coercePriority(value: unknown): Priority | null {
+ if (typeof value !== "string") return null;
+ const upper = value.toUpperCase();
return isPriority(upper) ? upper : null;
}
export async function runCoachComment(
+ ctx: ResolvedProviderClient,
input: CoachInput,
): Promise {
- const ctx = getClient(input.provider);
- if (!ctx) return null;
-
const eventDescription = {
ISSUE_STALLED:
"An assigned agent has not moved this issue out of BACKLOG/TODO within the workspace SLA. The issue is stalled.",
AGENT_NOACK:
"The assigned agent did not comment on or transition this issue within the required acknowledgement window after assignment.",
- ISSUE_SLA_BREACH:
- "This issue has passed its per-issue SLA target with no resolution.",
+ ISSUE_SLA_BREACH: "This issue has passed its per-issue SLA target with no resolution.",
}[input.eventKind];
- const ageMinutes = Math.round(
- (Date.now() - input.issue.createdAt.getTime()) / 60_000,
- );
- const sinceUpdateMinutes = Math.round(
- (Date.now() - input.issue.updatedAt.getTime()) / 60_000,
- );
+ const ageMinutes = Math.round((Date.now() - input.issue.createdAt.getTime()) / 60_000);
+ const sinceUpdateMinutes = Math.round((Date.now() - input.issue.updatedAt.getTime()) / 60_000);
const commentsBlock = input.recentCommentBodies.length
? `\n\nRecent comments (oldest first):\n${input.recentCommentBodies
@@ -398,10 +464,7 @@ Use plain prose, no bullets, no headers. Do not address the agent directly.`;
],
});
} catch (err) {
- logger.warn(
- { err, provider: ctx.providerId },
- "ai.coach: chat call failed",
- );
+ logger.warn({ err, provider: ctx.providerId }, "ai.coach: chat call failed");
return null;
}
@@ -466,9 +529,7 @@ const DESCRIBE_SYSTEM =
* exactly two fences, so a description with a genuine embedded code block is
* left intact. Returns null for empty/nullish.
*/
-export function cleanDescriptionOutput(
- content: string | null | undefined,
-): string | null {
+export function cleanDescriptionOutput(content: string | null | undefined): string | null {
if (!content) return null;
let text = content.trim();
const fenceCount = (text.match(/```/g) ?? []).length;
@@ -480,10 +541,9 @@ export function cleanDescriptionOutput(
}
export async function runDescriptionDraft(
+ ctx: ResolvedProviderClient,
input: DescriptionInput,
): Promise {
- const ctx = getClient(input.provider);
- if (!ctx) return null;
try {
const completion = await ctx.client.chat.completions.create({
model: input.model || ctx.defaultModel,
@@ -504,13 +564,12 @@ export async function runDescriptionDraft(
}
export async function runDescriptionEnhance(
+ ctx: ResolvedProviderClient,
input: DescriptionInput,
): Promise {
- const ctx = getClient(input.provider);
- if (!ctx) return null;
const existing = input.description?.trim();
// Nothing to enhance → fall back to a fresh draft.
- if (!existing) return runDescriptionDraft(input);
+ if (!existing) return runDescriptionDraft(ctx, input);
try {
const completion = await ctx.client.chat.completions.create({
model: input.model || ctx.defaultModel,
@@ -541,10 +600,10 @@ export async function runDescriptionEnhance(
// works without dispatching to an external agent runtime. The output is mapped
// to `AddStepInput[]` by the caller (orchestration-service.generatePlanForGoal).
//
-// Unlike runTriage/runCoachComment (env-only via getClient), the caller passes
-// an already-resolved client from `resolveWorkspaceProviderClient` so a
-// DB-credential-only workspace works too. Returns null on any failure — the
-// caller surfaces a typed error and never persists a dead empty plan.
+// The caller passes an already-resolved workspace client, matching triage,
+// Coach, and description assist so DB-credential-only workspaces work too.
+// Returns null on any failure — the caller surfaces a typed error and never
+// persists a dead empty plan.
// ---------------------------------------------------------------------------
export interface PlanGenInput {
@@ -586,8 +645,7 @@ Decompose this goal into a short, ordered list of concrete execution steps (typi
type: "function",
function: {
name: "submit_plan",
- description:
- "Submit the decomposed execution plan as an ordered list of steps.",
+ description: "Submit the decomposed execution plan as an ordered list of steps.",
parameters: {
type: "object",
properties: {
@@ -614,8 +672,7 @@ Decompose this goal into a short, ordered list of concrete execution steps (typi
depends_on_step_indexes: {
type: "array",
items: { type: "integer" },
- description:
- "0-based indexes of prerequisite steps in this same list.",
+ description: "0-based indexes of prerequisite steps in this same list.",
},
assigned_role: {
type: ["string", "null"],
@@ -656,10 +713,7 @@ Decompose this goal into a short, ordered list of concrete execution steps (typi
tool_choice: { type: "function", function: { name: "submit_plan" } },
});
} catch (err) {
- logger.warn(
- { err, provider: client.providerId },
- "ai.plan: chat call failed",
- );
+ logger.warn({ err, provider: client.providerId }, "ai.plan: chat call failed");
return null;
}
@@ -913,7 +967,9 @@ function markdownDetails(lines: string[]): {
const clean = cleanMarkdownInline(line.replace(/^\s*[-*+]\s+/, ""));
if (!clean) continue;
- const expected = clean.match(/^(?:expected output|expected_output|deliverable|output):\s*(.+)$/i);
+ const expected = clean.match(
+ /^(?:expected output|expected_output|deliverable|output):\s*(.+)$/i,
+ );
if (expected?.[1]) {
expectedOutput = expected[1].trim();
continue;
@@ -999,9 +1055,7 @@ function coerceStringArray(value: unknown): string[] {
function coerceIntegerArray(value: unknown): number[] {
if (!Array.isArray(value)) return [];
- return value.filter(
- (n): n is number => typeof n === "number" && Number.isInteger(n),
- );
+ return value.filter((n): n is number => typeof n === "number" && Number.isInteger(n));
}
function coerceRole(value: unknown): "WORKER" | "REVIEWER" | null {
@@ -1014,13 +1068,7 @@ function isPriority(value: unknown): value is Priority {
return (
typeof value === "string" &&
(
- [
- Priority.NONE,
- Priority.LOW,
- Priority.MEDIUM,
- Priority.HIGH,
- Priority.URGENT,
- ] as string[]
+ [Priority.NONE, Priority.LOW, Priority.MEDIUM, Priority.HIGH, Priority.URGENT] as string[]
).includes(value)
);
}
diff --git a/tests/lifecycle/lifecycle-journey.spec.ts b/tests/lifecycle/lifecycle-journey.spec.ts
new file mode 100644
index 00000000..2ea3157b
--- /dev/null
+++ b/tests/lifecycle/lifecycle-journey.spec.ts
@@ -0,0 +1,112 @@
+import { expect, test, type Page } from "@playwright/test";
+import AxeBuilder from "@axe-core/playwright";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const AUDIT_DIR = resolve(process.env.LIFECYCLE_AUDIT_DIR ?? "test-results/lifecycle-audit");
+
+async function capture(page: Page, name: string) {
+ mkdirSync(AUDIT_DIR, { recursive: true });
+ await page.screenshot({ path: join(AUDIT_DIR, `${name}.png`), fullPage: true });
+}
+
+async function recordAccessibility(page: Page, name: string) {
+ const result = await new AxeBuilder({ page }).disableRules(["color-contrast"]).analyze();
+ mkdirSync(AUDIT_DIR, { recursive: true });
+ writeFileSync(
+ join(AUDIT_DIR, `${name}-accessibility.json`),
+ JSON.stringify(result.violations, null, 2),
+ );
+ const serious = result.violations.filter(
+ (violation) => violation.impact === "critical" || violation.impact === "serious",
+ );
+ expect(serious, JSON.stringify(serious, null, 2)).toEqual([]);
+}
+
+test.describe("Issue lifecycle operator journey", () => {
+ test.beforeEach(async ({ page }) => {
+ await page.addInitScript(() => localStorage.setItem("theme", "dark"));
+ await page.setViewportSize({ width: 1440, height: 1100 });
+ });
+
+ test("returns to a complete Command Center after navigation", async ({ page }) => {
+ await page.goto("/w/forge/command-center");
+
+ const content = page.getByTestId("command-center-content");
+ await expect(content).toBeVisible();
+ await expect(page.getByText("Asks", { exact: true })).toBeVisible();
+ await expect(page.getByText("Runtime approvals", { exact: true })).toBeVisible();
+ await expect(page.getByText("Review gates", { exact: true })).toBeVisible();
+ await expect(page.getByText("Stalled runs", { exact: true })).toBeVisible();
+ await expect(page.getByText("FRG-9003", { exact: true })).toBeVisible();
+ await expect(page.getByText("Running lifecycle regression tests").first()).toBeVisible();
+ await capture(page, "01-command-center-desktop");
+ await recordAccessibility(page, "01-command-center-desktop");
+
+ await page.goto("/w/forge/issues/clifecycleactive000000000001");
+ await expect(
+ page.getByRole("heading", { name: "Lifecycle Lab · Agent actively working" }),
+ ).toBeVisible();
+ await expect(page.getByLabel("Agent workstream")).toContainText(
+ "Running lifecycle regression tests",
+ );
+
+ await page.goto("/w/forge/issues/clifecyclewaiting0000000001");
+ await expect(
+ page.getByRole("heading", { name: "Lifecycle Lab · Waiting for user reply" }),
+ ).toBeVisible();
+ await expect(page.getByLabel("Agent workstream")).toContainText(/Waiting on you/i);
+ await page.reload();
+ await expect(page.getByLabel("Agent workstream")).toContainText(/Waiting on you/i);
+ await capture(page, "02-waiting-issue-desktop");
+ await recordAccessibility(page, "02-waiting-issue-desktop");
+
+ await page.goto("/w/forge/command-center");
+ await expect(page.getByText("Choose the completion-summary emphasis").first()).toBeVisible();
+ });
+
+ test("Inbox and shared notifications preserve distinct kinds of attention", async ({ page }) => {
+ await page.goto("/w/forge/inbox");
+ await expect(page.getByRole("heading", { name: /Needs your input/ })).toBeVisible();
+ await expect(page.getByText("Choose the completion-summary emphasis")).toBeVisible();
+ await capture(page, "03-inbox-desktop");
+ await recordAccessibility(page, "03-inbox-desktop");
+
+ const bell = page.getByRole("button", { name: /(?:unread|no unread) item/i });
+ await bell.click();
+ const drawer = page.getByRole("dialog", { name: "Activity" });
+ await expect(drawer).toBeVisible();
+ await expect(drawer.getByText("FRG-9008 stalled")).toBeVisible();
+ await capture(page, "04-shared-notifications-desktop");
+ await recordAccessibility(page, "04-shared-notifications-desktop");
+ });
+
+ test("completed work keeps its final handoff and terminal state", async ({ page }) => {
+ await page.goto("/w/forge/issues/clifecyclecompleted00000001");
+ await expect(
+ page.getByRole("heading", { name: "Lifecycle Lab · Completed with final handoff" }),
+ ).toBeVisible();
+ await expect(page.getByText(/Completed\. The operator journey now exposes/)).toBeVisible();
+ await expect(page.getByRole("combobox", { name: "Status" })).toContainText("Done");
+ await capture(page, "05-completed-issue-desktop");
+ await recordAccessibility(page, "05-completed-issue-desktop");
+ });
+
+ test("attention remains usable on a narrow viewport", async ({ page }) => {
+ await page.setViewportSize({ width: 390, height: 844 });
+ await page.goto("/w/forge/command-center");
+ const content = page.getByTestId("command-center-content");
+ await expect(content).toBeVisible();
+ await expect(page.getByText("Asks", { exact: true })).toBeVisible();
+ const overflow = await page.evaluate(() =>
+ Math.max(
+ 0,
+ document.documentElement.scrollWidth - document.documentElement.clientWidth,
+ document.body.scrollWidth - document.body.clientWidth,
+ ),
+ );
+ expect(overflow).toBeLessThanOrEqual(1);
+ await capture(page, "06-command-center-mobile");
+ await recordAccessibility(page, "06-command-center-mobile");
+ });
+});
diff --git a/tests/unit/ai-triage-lease.test.ts b/tests/unit/ai-triage-lease.test.ts
new file mode 100644
index 00000000..2b16b842
--- /dev/null
+++ b/tests/unit/ai-triage-lease.test.ts
@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { AI_TRIAGE_PENDING_LEASE_MS, isAiTriagePendingStale } from "@/lib/ai-triage";
+
+describe("AI triage pending lease", () => {
+ it("keeps a recent claim active", () => {
+ const now = Date.now();
+ expect(isAiTriagePendingStale(new Date(now - 1_000), now)).toBe(false);
+ });
+
+ it("allows retry after the lease and recovers legacy pending rows without a timestamp", () => {
+ const now = Date.now();
+ expect(isAiTriagePendingStale(new Date(now - AI_TRIAGE_PENDING_LEASE_MS), now)).toBe(true);
+ expect(isAiTriagePendingStale(null, now)).toBe(true);
+ });
+});
diff --git a/tests/unit/ai-triage-parse.test.ts b/tests/unit/ai-triage-parse.test.ts
index 658dcf39..dbb641fd 100644
--- a/tests/unit/ai-triage-parse.test.ts
+++ b/tests/unit/ai-triage-parse.test.ts
@@ -1,12 +1,18 @@
import { describe, expect, it } from "vitest";
-import { parseTriageMessage } from "@/server/services/ai";
+import { parseTriageMessage, runTriage } from "@/server/services/ai";
+import type { ResolvedProviderClient } from "@/server/services/ai-providers";
const LABEL_BUG = "cmofy50kw0001o107hc8dzsft";
const LABEL_UI = "cmofy50kw0002o107aaaaaaaa";
+const LABEL_HERMES = "cmofy50kw0003o107bbbbbbbb";
const AGENT_VICTOR = "cmagent0001victorxxxxxxxx";
-const validLabels = new Set([LABEL_BUG, LABEL_UI]);
-const validAgents = new Set([AGENT_VICTOR]);
+const labels = [
+ { id: LABEL_BUG, name: "Bug" },
+ { id: LABEL_UI, name: "UI" },
+ { id: LABEL_HERMES, name: "Hermes" },
+];
+const agents = [{ id: AGENT_VICTOR, profileKey: "victor", name: "Victor" }];
describe("parseTriageMessage", () => {
it("parses a well-formed submit_triage tool call", () => {
@@ -27,7 +33,7 @@ describe("parseTriageMessage", () => {
},
],
};
- const out = parseTriageMessage(message, validLabels, validAgents);
+ const out = parseTriageMessage(message, labels, agents);
expect(out).toEqual({
priority: "HIGH",
labelIds: [LABEL_BUG],
@@ -36,9 +42,25 @@ describe("parseTriageMessage", () => {
});
});
- it("falls back to prose when the provider ignores tool_choice (the Hermes case)", () => {
- // Verbatim shape of what the Hermes gateway returned in prod: plain prose,
- // no tool call, but a usable recommendation that names the valid label id.
+ it("recovers the exact AXI-104 name-only recommendation without exposing tool failure prose", () => {
+ const message = {
+ role: "assistant",
+ content:
+ "Triage submission failed because the project tool reported “Unknown tool: submit_triage.” " +
+ "Recommended triage: LOW priority; labels Bug and Hermes; assign Victor. " +
+ "The issue is a scoped Hermes-Relay configuration bug with no stated outage or data-loss impact.",
+ };
+ const out = parseTriageMessage(message, labels, agents);
+ expect(out).toEqual({
+ priority: "LOW",
+ labelIds: [LABEL_BUG, LABEL_HERMES],
+ agentId: AGENT_VICTOR,
+ reasoning:
+ "The issue is a scoped Hermes-Relay configuration bug with no stated outage or data-loss impact.",
+ });
+ });
+
+ it("falls back to labelled prose when a provider ignores tool_choice", () => {
const message = {
role: "assistant",
content:
@@ -47,12 +69,50 @@ describe("parseTriageMessage", () => {
`Priority: LOW\nLabels: Bug (${LABEL_BUG})\nAgent: none\n\n` +
"Reasoning: Pinned issues being hard to remove is a UI bug but shows no urgency.",
};
- const out = parseTriageMessage(message, validLabels, validAgents);
+ const out = parseTriageMessage(message, labels, agents);
expect(out).not.toBeNull();
expect(out!.priority).toBe("LOW");
expect(out!.labelIds).toEqual([LABEL_BUG]);
expect(out!.agentId).toBeNull();
- expect(out!.reasoning).toContain("Pinned issues");
+ expect(out!.reasoning).toBe(
+ "Pinned issues being hard to remove is a UI bug but shows no urgency.",
+ );
+ });
+
+ it("maps structured label names and agent handles when a compatible model returns names", () => {
+ const message = {
+ role: "assistant",
+ content: JSON.stringify({
+ priority: "medium",
+ label_ids: ["UI"],
+ agent_id: "victor",
+ reasoning: "A focused interface repair.",
+ }),
+ };
+ expect(parseTriageMessage(message, labels, agents)).toEqual({
+ priority: "MEDIUM",
+ labelIds: [LABEL_UI],
+ agentId: AGENT_VICTOR,
+ reasoning: "A focused interface repair.",
+ });
+ });
+
+ it("does not infer an assignment from an agent name used only in reasoning", () => {
+ const message = {
+ role: "assistant",
+ content:
+ "Priority: LOW. Labels: Bug. Reasoning: Victor reported the issue but ownership is unclear.",
+ };
+ expect(parseTriageMessage(message, labels, agents)?.agentId).toBeNull();
+ });
+
+ it("refuses ambiguous name-only agent matches", () => {
+ const duplicateNames = [
+ ...agents,
+ { id: "cmagent0002victorxxxxxxxx", profileKey: "victor-2", name: "Victor" },
+ ];
+ const message = { role: "assistant", content: "Priority: HIGH. Assign Victor." };
+ expect(parseTriageMessage(message, labels, duplicateNames)?.agentId).toBeNull();
});
it("parses a fenced JSON block embedded in content", () => {
@@ -68,24 +128,13 @@ describe("parseTriageMessage", () => {
}) +
"\n```",
};
- const out = parseTriageMessage(message, validLabels, validAgents);
- expect(out).toMatchObject({
+ expect(parseTriageMessage(message, labels, agents)).toMatchObject({
priority: "MEDIUM",
labelIds: [LABEL_UI],
agentId: null,
});
});
- it("extracts a valid agent id mentioned in prose", () => {
- const message = {
- role: "assistant",
- content: `Priority: URGENT. Assign agent ${AGENT_VICTOR}. Reasoning: outage.`,
- };
- const out = parseTriageMessage(message, validLabels, validAgents);
- expect(out!.priority).toBe("URGENT");
- expect(out!.agentId).toBe(AGENT_VICTOR);
- });
-
it("drops label/agent ids that aren't in the workspace", () => {
const message = {
role: "assistant",
@@ -93,7 +142,7 @@ describe("parseTriageMessage", () => {
"Priority: HIGH. Labels: cmNOTAREALLABELxxxxxxxxxx. " +
"Agent: cmNOTAREALAGENTxxxxxxxxxx. Reasoning: bogus ids.",
};
- const out = parseTriageMessage(message, validLabels, validAgents);
+ const out = parseTriageMessage(message, labels, agents);
expect(out!.labelIds).toEqual([]);
expect(out!.agentId).toBeNull();
});
@@ -101,16 +150,61 @@ describe("parseTriageMessage", () => {
it("returns null when the model refuses with no usable priority", () => {
const message = {
role: "assistant",
- content:
- "I can't submit the triage because the required submit_triage tool isn't available.",
+ content: "I can't submit the triage because the required submit_triage tool isn't available.",
};
- expect(parseTriageMessage(message, validLabels, validAgents)).toBeNull();
+ expect(parseTriageMessage(message, labels, agents)).toBeNull();
});
- it("returns null for an empty / contentless message", () => {
- expect(parseTriageMessage(undefined, validLabels, validAgents)).toBeNull();
- expect(
- parseTriageMessage({ role: "assistant", content: "" }, validLabels, validAgents),
- ).toBeNull();
+ it("returns null for an empty or contentless message", () => {
+ expect(parseTriageMessage(undefined, labels, agents)).toBeNull();
+ expect(parseTriageMessage({ role: "assistant", content: "" }, labels, agents)).toBeNull();
+ });
+});
+
+describe("runTriage", () => {
+ it("requests plain JSON from Hermes without registering a server-side tool", async () => {
+ let captured: Record | null = null;
+ const provider = {
+ providerId: "hermes",
+ defaultModel: "test-model",
+ supportsImageInput: true,
+ client: {
+ chat: {
+ completions: {
+ create: async (request: Record) => {
+ captured = request;
+ return {
+ choices: [
+ {
+ finish_reason: "stop",
+ message: {
+ role: "assistant",
+ content: JSON.stringify({
+ priority: "LOW",
+ label_ids: [LABEL_BUG],
+ agent_id: AGENT_VICTOR,
+ reasoning: "Scoped bug.",
+ }),
+ },
+ },
+ ],
+ };
+ },
+ },
+ },
+ },
+ } as unknown as ResolvedProviderClient;
+
+ const result = await runTriage(provider, {
+ title: "Hermes configuration bug",
+ description: null,
+ workspaceLabels: labels.map((label) => ({ ...label, color: "#000000" })),
+ agents: agents.map((agent) => ({ ...agent, capabilities: ["hermes"] })),
+ });
+
+ expect(result?.agentId).toBe(AGENT_VICTOR);
+ expect(captured).not.toHaveProperty("tools");
+ expect(captured).not.toHaveProperty("tool_choice");
+ expect(captured).toMatchObject({ model: "test-model" });
});
});
diff --git a/tsconfig.json b/tsconfig.json
index c747a769..05c9164f 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -36,7 +36,8 @@
"**/*.tsx",
".next/types/**/*.ts",
"next-env.d.ts",
- ".next-e2e/types/**/*.ts"
+ ".next-e2e/types/**/*.ts",
+ ".next-lifecycle/types/**/*.ts"
],
"exclude": [
"node_modules",