fix(agents): reset rehire onboarding state and harden cycle projection

Author: 0xTomDaniel

typescript/clients/web-ag-ui/apps/agent-clmm/src/accounting/snapshot.ts

@@ -110,6 +110,10 @@ function extractManagedPools(params: {
   flowLog?: FlowLogEvent[];
   managedPoolAddresses?: Array<`0x${string}`>;
 }): Set<string> | null {
+  if (params.managedPoolAddresses && params.managedPoolAddresses.length > 0) {
+    return new Set(params.managedPoolAddresses.map((poolAddress) => poolAddress.toLowerCase()));
+  }
+
   const pools = new Set<string>();
   if (params.flowLog) {
     for (const event of params.flowLog) {
@@ -121,11 +125,6 @@ function extractManagedPools(params: {
       }
     }
   }
-  if (pools.size === 0 && params.managedPoolAddresses) {
-    for (const poolAddress of params.managedPoolAddresses) {
-      pools.add(poolAddress.toLowerCase());
-    }
-  }
   return pools.size > 0 ? pools : null;
 }
 

typescript/clients/web-ag-ui/apps/agent-clmm/src/accounting/snapshot.unit.test.ts

@@ -248,6 +248,56 @@ describe('createCamelotNavSnapshot', () => {
     expect(call?.positions[0]?.poolAddress).toBe('0xpool1');
   });
 
+  it('prefers explicit managed pool addresses over stale flow-log pool entries', async () => {
+    const { createCamelotNavSnapshot } = await import('./snapshot.js');
+
+    const positions: WalletPosition[] = [
+      basePosition,
+      { ...basePosition, poolAddress: '0xpool2' },
+    ];
+    const flowLog: FlowLogEvent[] = [
+      {
+        id: 'flow-supply-old',
+        type: 'supply',
+        timestamp: '2025-01-01T00:00:00.000Z',
+        contextId: 'ctx-1',
+        chainId: 42161,
+        protocolId: 'camelot-clmm',
+        poolAddress: '0xpool1',
+      },
+    ];
+
+    const poolTwo: CamelotPool = {
+      ...basePool,
+      address: '0xpool2',
+    };
+    const { client } = buildClient({ positions, pools: [basePool, poolTwo] });
+    resolveTokenPriceMap.mockResolvedValue(new Map());
+    computeCamelotPositionValues.mockReturnValue([
+      {
+        positionId: 'camelot-0xpool2-0',
+        poolAddress: '0xpool2',
+        protocolId: 'camelot-clmm',
+        tokens: [],
+        positionValueUsd: 123,
+      },
+    ]);
+
+    await createCamelotNavSnapshot({
+      contextId: 'ctx-1',
+      trigger: 'cycle',
+      walletAddress: '0xabc',
+      chainId: 42161,
+      camelotClient: client,
+      flowLog,
+      managedPoolAddresses: ['0xpool2'],
+    });
+
+    const call = computeCamelotPositionValues.mock.calls[0]?.[0];
+    expect(call?.positions).toHaveLength(1);
+    expect(call?.positions[0]?.poolAddress).toBe('0xpool2');
+  });
+
   it('reports mixed pricing sources and aggregates fees/rewards', async () => {
     const { createCamelotNavSnapshot } = await import('./snapshot.js');
 

typescript/clients/web-ag-ui/apps/agent-clmm/src/workflow/accounting.ts

@@ -44,16 +44,20 @@ export async function createCamelotAccountingSnapshot(params: {
     return null;
   }
 
+  const managedPoolAddress =
+    params.state.thread.selectedPool?.address ??
+    params.state.thread.operatorInput?.poolAddress ??
+    params.state.thread.metrics.lastSnapshot?.address ??
+    params.state.thread.metrics.latestSnapshot?.poolAddress;
+
   return createCamelotNavSnapshot({
     contextId,
     trigger: params.trigger,
     walletAddress,
     chainId: ARBITRUM_CHAIN_ID,
     camelotClient: params.camelotClient,
     flowLog: params.flowLog ?? params.state.thread.accounting.flowLog,
-    managedPoolAddresses: params.state.thread.selectedPool
-      ? [params.state.thread.selectedPool.address]
-      : undefined,
+    managedPoolAddresses: managedPoolAddress ? [managedPoolAddress] : undefined,
     transactionHash: params.transactionHash,
     threadId: params.threadId,
     cycle: params.cycle,

typescript/clients/web-ag-ui/apps/agent-clmm/src/workflow/accounting.unit.test.ts

@@ -78,4 +78,54 @@ describe('createCamelotAccountingSnapshot', () => {
     expect(result).toBeNull();
     expect(createCamelotNavSnapshot).not.toHaveBeenCalled();
   });
+
+  it('uses operator input pool as managed pool fallback when selected pool is missing', async () => {
+    const { createCamelotAccountingSnapshot } = await import('./accounting.js');
+
+    createCamelotNavSnapshot.mockResolvedValue({
+      contextId: 'thread-1',
+      trigger: 'cycle',
+      timestamp: '2026-02-20T00:00:00.000Z',
+      protocolId: 'camelot-clmm',
+      walletAddress: '0x1111111111111111111111111111111111111111',
+      chainId: 42161,
+      totalUsd: 1,
+      positions: [],
+      priceSource: 'unknown',
+    });
+
+    const state = {
+      thread: {
+        operatorInput: {
+          poolAddress: '0x3333333333333333333333333333333333333333',
+          walletAddress: '0x1111111111111111111111111111111111111111',
+          baseContributionUsd: 10,
+        },
+        operatorConfig: {
+          walletAddress: '0x1111111111111111111111111111111111111111',
+        },
+        selectedPool: undefined,
+        metrics: {
+          lastSnapshot: undefined,
+          latestSnapshot: undefined,
+        },
+        accounting: {
+          flowLog: [],
+        },
+      },
+    } as unknown as ClmmState;
+
+    await createCamelotAccountingSnapshot({
+      state,
+      camelotClient: {} as never,
+      trigger: 'cycle',
+      threadId: 'thread-1',
+    });
+
+    expect(createCamelotNavSnapshot).toHaveBeenCalledWith(
+      expect.objectContaining({
+        managedPoolAddresses: ['0x3333333333333333333333333333333333333333'],
+      }),
+    );
+  });
 });

typescript/clients/web-ag-ui/apps/agent-clmm/src/workflow/nodes/fireCommand.ts

@@ -1,6 +1,7 @@
 import { copilotkitEmitState } from '@copilotkit/sdk-js/langgraph';
 
 import { applyAccountingUpdate, createFlowEvent } from '../../accounting/state.js';
+import { fetchPoolSnapshot } from '../../clients/emberApi.js';
 import { ARBITRUM_CHAIN_ID } from '../../config/constants.js';
 import type { ClmmAction } from '../../domain/types.js';
 import { resolveAccountingContextId } from '../accounting.js';
@@ -41,14 +42,28 @@ export const fireCommandNode = async (
     };
   }
 
-  const onboardingComplete = Boolean(state.thread.operatorConfig && state.thread.selectedPool);
-  if (!onboardingComplete) {
+  const operatorConfig = state.thread.operatorConfig;
+  let selectedPool = state.thread.selectedPool ?? state.thread.metrics.lastSnapshot;
+  const fallbackPoolAddress =
+    state.thread.operatorInput?.poolAddress ??
+    state.thread.metrics.lastSnapshot?.address ??
+    state.thread.metrics.latestSnapshot?.poolAddress;
+  let camelotClient = undefined as ReturnType<typeof getCamelotClient> | undefined;
+  if (operatorConfig && !selectedPool && fallbackPoolAddress) {
+    camelotClient = getCamelotClient();
+    selectedPool =
+      (await fetchPoolSnapshot(
+        camelotClient,
+        fallbackPoolAddress,
+        ARBITRUM_CHAIN_ID,
+      )) ?? undefined;
+  }
+
+  if (!operatorConfig) {
     const { task, statusEvent } = buildTaskStatus(
       currentTask,
-      state.thread.operatorConfig ? 'failed' : 'canceled',
-      state.thread.operatorConfig
-        ? 'Agent fired, but workflow is missing a selected pool.'
-        : 'Agent fired before onboarding completed.',
+      'canceled',
+      'Agent fired before onboarding completed.',
     );
     await copilotkitEmitState(config, {
       thread: { task, activity: { events: [statusEvent], telemetry: [] } },
@@ -66,13 +81,11 @@ export const fireCommandNode = async (
     };
   }
 
-  const operatorConfig = state.thread.operatorConfig;
-  const selectedPool = state.thread.selectedPool;
-  if (!operatorConfig || !selectedPool) {
+  if (!selectedPool) {
     const { task, statusEvent } = buildTaskStatus(
       currentTask,
-      'failed',
-      'Agent fired, but workflow state is missing operatorConfig or selectedPool.',
+      'completed',
+      'Agent fired. Managed CLMM pool metadata is unavailable, so unwind was skipped.',
     );
     await copilotkitEmitState(config, {
       thread: { task, activity: { events: [statusEvent], telemetry: [] } },
@@ -125,7 +138,7 @@ export const fireCommandNode = async (
     },
   });
 
-  const camelotClient = getCamelotClient();
+  const executionCamelotClient = camelotClient ?? getCamelotClient();
   let txHash: string | undefined;
   let executionFlowEvents: Array<ReturnType<typeof createFlowEvent>> = [];
   try {
@@ -136,7 +149,7 @@ export const fireCommandNode = async (
     };
     const outcome = await executeDecision({
       action,
-      camelotClient,
+      camelotClient: executionCamelotClient,
       pool: selectedPool,
       operatorConfig,
       fundingTokenAddress: state.thread.fundingTokenInput?.fundingTokenAddress,