feat: inherit definition strategy config into agent runs

Author: WordClaw Agent

src/__tests__/api-tenant.test.ts

@@ -479,4 +479,69 @@ describe('Multi-Tenant Domain Isolation Tests', () => {
             }
         }
     });
+
+    it('agent-run creation from definition inherits strategy config and definition runType', async () => {
+        let domain1DefinitionId: number | null = null;
+        let domain1RunId: number | null = null;
+
+        try {
+            const createDefinition = await fastify.inject({
+                method: 'POST',
+                url: '/api/agent-run-definitions',
+                headers: { 'x-api-key': rawKey1 },
+                payload: {
+                    name: `d1-inherit-${crypto.randomUUID().slice(0, 8)}`,
+                    runType: 'quality_refiner',
+                    strategyConfig: {
+                        maxCandidates: 5,
+                        safeMode: true
+                    },
+                    active: true
+                }
+            });
+            expect(createDefinition.statusCode).toBe(201);
+            domain1DefinitionId = JSON.parse(createDefinition.payload).data.id as number;
+
+            const createRun = await fastify.inject({
+                method: 'POST',
+                url: '/api/agent-runs',
+                headers: { 'x-api-key': rawKey1 },
+                payload: {
+                    goal: 'Run from template',
+                    definitionId: domain1DefinitionId,
+                    runType: 'review_backlog_manager',
+                    metadata: {
+                        safeMode: false,
+                        operator: 'tenant-test'
+                    }
+                }
+            });
+            expect(createRun.statusCode).toBe(201);
+
+            const runPayload = JSON.parse(createRun.payload) as {
+                data: {
+                    id: number;
+                    runType: string;
+                    definitionId: number | null;
+                    metadata: Record<string, unknown> | null;
+                };
+            };
+            domain1RunId = runPayload.data.id;
+
+            expect(runPayload.data.definitionId).toBe(domain1DefinitionId);
+            expect(runPayload.data.runType).toBe('quality_refiner');
+            expect(runPayload.data.metadata).toEqual({
+                maxCandidates: 5,
+                safeMode: false,
+                operator: 'tenant-test'
+            });
+        } finally {
+            if (domain1RunId) {
+                await db.delete(agentRuns).where(eq(agentRuns.id, domain1RunId));
+            }
+            if (domain1DefinitionId) {
+                await db.delete(agentRunDefinitions).where(eq(agentRunDefinitions.id, domain1DefinitionId));
+            }
+        }
+    });
 });

src/services/agent-runs.ts

@@ -100,6 +100,10 @@ function clampOffset(offset?: number): number {
     return Math.max(0, offset);
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
 function isUniqueViolation(error: unknown, constraintName: string): boolean {
     const visited = new Set<unknown>();
     let candidate: unknown = error;
@@ -365,6 +369,7 @@ export class AgentRunService {
 
         let definitionId: number | null = null;
         let inferredRunType: string | null = null;
+        let baseMetadata: Record<string, unknown> = {};
 
         if (input.definitionId !== undefined) {
             const [definition] = await db.select()
@@ -383,9 +388,16 @@ export class AgentRunService {
 
             definitionId = definition.id;
             inferredRunType = definition.runType;
+            if (isRecord(definition.strategyConfig)) {
+                baseMetadata = definition.strategyConfig;
+            }
         }
 
-        const runType = input.runType?.trim() || inferredRunType || 'review_backlog_manager';
+        const runType = inferredRunType || input.runType?.trim() || 'review_backlog_manager';
+        const metadata = {
+            ...baseMetadata,
+            ...(input.metadata ?? {})
+        };
         const status: AgentRunStatus = input.requireApproval ? 'waiting_approval' : 'queued';
 
         const created = await db.transaction(async (tx) => {
@@ -396,7 +408,7 @@ export class AgentRunService {
                 runType,
                 status,
                 requestedBy: input.requestedBy,
-                metadata: input.metadata ?? null
+                metadata: Object.keys(metadata).length > 0 ? metadata : null
             }).returning();
 
             await tx.insert(agentRunSteps).values({
@@ -416,7 +428,9 @@ export class AgentRunService {
                     status: newRun.status,
                     goal: newRun.goal,
                     runType: newRun.runType,
-                    requestedBy: newRun.requestedBy
+                    requestedBy: newRun.requestedBy,
+                    definitionId: newRun.definitionId,
+                    metadata: newRun.metadata
                 }
             });